Coverage Report - com.googlecode.sparkleg.SparqlParser
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlParser
92%
13283/14321
25%
1244/4956
11,626
SparqlParser$DFA4
95%
22/23
N/A
11,626
SparqlParser$add_return
0%
0/2
N/A
11,626
SparqlParser$additiveExpression_return
100%
4/4
N/A
11,626
SparqlParser$additiveOperator_return
100%
4/4
N/A
11,626
SparqlParser$aggregate_return
100%
4/4
N/A
11,626
SparqlParser$anon_return
100%
4/4
N/A
11,626
SparqlParser$argList_return
100%
4/4
N/A
11,626
SparqlParser$askQuery_return
100%
4/4
N/A
11,626
SparqlParser$baseDecl_return
100%
4/4
N/A
11,626
SparqlParser$bind_return
100%
4/4
N/A
11,626
SparqlParser$bindingValueList_return
100%
4/4
N/A
11,626
SparqlParser$bindingValue_return
100%
4/4
N/A
11,626
SparqlParser$bindingsClause_return
100%
4/4
N/A
11,626
SparqlParser$blankNode_return
100%
4/4
N/A
11,626
SparqlParser$booleanLiteral_return
100%
4/4
N/A
11,626
SparqlParser$brackettedExpression_return
100%
4/4
N/A
11,626
SparqlParser$builtInCall_return
100%
4/4
N/A
11,626
SparqlParser$clear_return
100%
4/4
N/A
11,626
SparqlParser$conditionalAndExpression_return
100%
4/4
N/A
11,626
SparqlParser$conditionalOrExpression_return
100%
4/4
N/A
11,626
SparqlParser$constraint_return
100%
4/4
N/A
11,626
SparqlParser$constructQuery_return
100%
4/4
N/A
11,626
SparqlParser$constructTemplate_return
100%
4/4
N/A
11,626
SparqlParser$constructTriples_return
100%
4/4
N/A
11,626
SparqlParser$copy_return
0%
0/2
N/A
11,626
SparqlParser$create_return
0%
0/2
N/A
11,626
SparqlParser$datasetClause_return
100%
4/4
N/A
11,626
SparqlParser$deleteClause_return
100%
4/4
N/A
11,626
SparqlParser$deleteData_return
100%
4/4
N/A
11,626
SparqlParser$deleteWhere_return
100%
4/4
N/A
11,626
SparqlParser$delete_return
100%
4/4
N/A
11,626
SparqlParser$describeQuery_return
100%
4/4
N/A
11,626
SparqlParser$drop_return
100%
4/4
N/A
11,626
SparqlParser$existsFunction_return
100%
4/4
N/A
11,626
SparqlParser$expressionList_return
100%
4/4
N/A
11,626
SparqlParser$expression_return
100%
4/4
N/A
11,626
SparqlParser$filter_return
100%
4/4
N/A
11,626
SparqlParser$functionCall_return
100%
4/4
N/A
11,626
SparqlParser$graphGraphPattern_return
100%
4/4
N/A
11,626
SparqlParser$graphNode_return
100%
4/4
N/A
11,626
SparqlParser$graphOrDefault_return
0%
0/2
N/A
11,626
SparqlParser$graphPatternNotTriples_return
100%
4/4
N/A
11,626
SparqlParser$graphRefAll_return
100%
4/4
N/A
11,626
SparqlParser$graphRef_return
100%
4/4
N/A
11,626
SparqlParser$graphTerm_return
100%
4/4
N/A
11,626
SparqlParser$groupClause_return
100%
4/4
N/A
11,626
SparqlParser$groupCondition_return
100%
4/4
N/A
11,626
SparqlParser$groupGraphPatternSubDetail_return
100%
4/4
N/A
11,626
SparqlParser$groupGraphPatternSub_return
100%
4/4
N/A
11,626
SparqlParser$groupGraphPattern_return
100%
4/4
N/A
11,626
SparqlParser$groupOrUnionGraphPattern_return
100%
4/4
N/A
11,626
SparqlParser$havingClause_return
100%
4/4
N/A
11,626
SparqlParser$insertClause_return
100%
4/4
N/A
11,626
SparqlParser$insert_return
100%
4/4
N/A
11,626
SparqlParser$iriRefOrFunction_return
100%
4/4
N/A
11,626
SparqlParser$iriRef_return
100%
4/4
N/A
11,626
SparqlParser$limitClause_return
100%
4/4
N/A
11,626
SparqlParser$limitOffsetClauses_return
100%
4/4
N/A
11,626
SparqlParser$load_return
0%
0/2
N/A
11,626
SparqlParser$minusGraphPattern_return
100%
4/4
N/A
11,626
SparqlParser$modify_return
100%
4/4
N/A
11,626
SparqlParser$move_return
0%
0/2
N/A
11,626
SparqlParser$multiplicativeExpression_return
100%
4/4
N/A
11,626
SparqlParser$multiplicativeOperator_return
100%
4/4
N/A
11,626
SparqlParser$nil_return
100%
4/4
N/A
11,626
SparqlParser$notExistsFunction_return
100%
4/4
N/A
11,626
SparqlParser$numericExpression_return
100%
4/4
N/A
11,626
SparqlParser$numericLiteralNegative_return
100%
4/4
N/A
11,626
SparqlParser$numericLiteralPositive_return
100%
4/4
N/A
11,626
SparqlParser$numericLiteralUnsigned_return
100%
4/4
N/A
11,626
SparqlParser$numericLiteral_return
100%
4/4
N/A
11,626
SparqlParser$objectList_return
100%
4/4
N/A
11,626
SparqlParser$offsetClause_return
100%
4/4
N/A
11,626
SparqlParser$optionalGraphPattern_return
100%
4/4
N/A
11,626
SparqlParser$orderClause_return
100%
4/4
N/A
11,626
SparqlParser$orderCondition_return
100%
4/4
N/A
11,626
SparqlParser$pathEltOrInverse_return
100%
4/4
N/A
11,626
SparqlParser$pathElt_return
100%
4/4
N/A
11,626
SparqlParser$pathMod_return
100%
4/4
N/A
11,626
SparqlParser$pathNegatedPropertySet_return
100%
4/4
N/A
11,626
SparqlParser$pathOneInPropertySet_return
100%
4/4
N/A
11,626
SparqlParser$pathPrimary_return
100%
4/4
N/A
11,626
SparqlParser$pathSequence_return
100%
4/4
N/A
11,626
SparqlParser$path_return
100%
4/4
N/A
11,626
SparqlParser$prefixDecl_return
100%
4/4
N/A
11,626
SparqlParser$prefixedName_return
100%
4/4
N/A
11,626
SparqlParser$primaryExpression_return
100%
4/4
N/A
11,626
SparqlParser$prologue_return
100%
4/4
N/A
11,626
SparqlParser$propertyListNotEmptyDetails_return
100%
4/4
N/A
11,626
SparqlParser$propertyListNotEmptyPath_return
100%
4/4
N/A
11,626
SparqlParser$propertyListNotEmpty_return
100%
4/4
N/A
11,626
SparqlParser$quadPattern_return
100%
4/4
N/A
11,626
SparqlParser$quadsDetails_return
100%
4/4
N/A
11,626
SparqlParser$quadsNotTriples_return
100%
4/4
N/A
11,626
SparqlParser$quads_return
100%
4/4
N/A
11,626
SparqlParser$query_return
100%
4/4
N/A
11,626
SparqlParser$rdfLiteral_return
100%
4/4
N/A
11,626
SparqlParser$regexExpression_return
100%
4/4
N/A
11,626
SparqlParser$relationalExpression_return
100%
4/4
N/A
11,626
SparqlParser$selectClause_return
100%
4/4
N/A
11,626
SparqlParser$selectQuery_return
100%
4/4
N/A
11,626
SparqlParser$selectVariables_return
100%
4/4
N/A
11,626
SparqlParser$serviceGraphPattern_return
100%
4/4
N/A
11,626
SparqlParser$solutionModifier_return
100%
4/4
N/A
11,626
SparqlParser$strReplaceExpression_return
100%
4/4
N/A
11,626
SparqlParser$string_return
100%
4/4
N/A
11,626
SparqlParser$subSelect_return
100%
4/4
N/A
11,626
SparqlParser$subStringExpression_return
100%
4/4
N/A
11,626
SparqlParser$triplesBlock_return
100%
4/4
N/A
11,626
SparqlParser$triplesNode_return
100%
4/4
N/A
11,626
SparqlParser$triplesSameSubjectPath_return
100%
4/4
N/A
11,626
SparqlParser$triplesSameSubject_return
100%
4/4
N/A
11,626
SparqlParser$triplesTemplate_return
100%
4/4
N/A
11,626
SparqlParser$unaryExpression_return
100%
4/4
N/A
11,626
SparqlParser$update_return
100%
4/4
N/A
11,626
SparqlParser$usingClause_return
100%
4/4
N/A
11,626
SparqlParser$valueLogical_return
100%
4/4
N/A
11,626
SparqlParser$varOrIRIref_return
100%
4/4
N/A
11,626
SparqlParser$varOrTerm_return
100%
4/4
N/A
11,626
SparqlParser$var_return
100%
4/4
N/A
11,626
SparqlParser$verbPath_return
100%
4/4
N/A
11,626
SparqlParser$verbSimpleOrPath_return
100%
4/4
N/A
11,626
SparqlParser$verbSimple_return
100%
4/4
N/A
11,626
SparqlParser$verb_return
0%
0/2
N/A
11,626
SparqlParser$whereClause_return
100%
4/4
N/A
11,626
 
 1  
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\Sparql.g 2012-03-17 13:43:37
 2  
 
 3  
     package com.googlecode.sparkleg;
 4  
 
 5  
 
 6  
 import org.antlr.runtime.*;
 7  
 import java.util.Stack;
 8  
 import java.util.List;
 9  
 import java.util.ArrayList;
 10  
 
 11  
 import org.antlr.runtime.tree.*;
 12  
 
 13  
 
 14  
 /**
 15  
  * @author Simone Tripodi   (simone.tripodi)
 16  
  * @author Michele Mostarda (michele.mostarda)
 17  
  * @author Juergen Pfundt   (Juergen.Pfundt)
 18  
  * @version $Id: Sparql.g 226 2011-10-22 21:13:52Z Juergen.Pfundt@gmail.com $
 19  
  */
 20  
 @SuppressWarnings({"all", "warnings", "unchecked"})
 21  
 public class SparqlParser extends Parser {
 22  7
     public static final String[] tokenNames = new String[] {
 23  
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANON", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "COALESCE", "COLLECTION", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HEX", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NIL", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_ELT_OR_INVERSE", "PATH_MOD", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PERCENT", "PLUS", "PLX", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_LOCAL_ESC", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "RDFLITERAL", "REDUCED", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR", "'('", "')'", "','", "';'", "'['", "']'", "'^^'", "'{'", "'|'", "'}'"
 24  
     };
 25  
 
 26  
     public static final int EOF=-1;
 27  
     public static final int T__209=209;
 28  
     public static final int T__210=210;
 29  
     public static final int T__211=211;
 30  
     public static final int T__212=212;
 31  
     public static final int T__213=213;
 32  
     public static final int T__214=214;
 33  
     public static final int T__215=215;
 34  
     public static final int T__216=216;
 35  
     public static final int T__217=217;
 36  
     public static final int T__218=218;
 37  
     public static final int A=4;
 38  
     public static final int ABS=5;
 39  
     public static final int ADD=6;
 40  
     public static final int ALL=7;
 41  
     public static final int AND=8;
 42  
     public static final int ANON=9;
 43  
     public static final int ANY=10;
 44  
     public static final int ARG_LIST=11;
 45  
     public static final int AS=12;
 46  
     public static final int ASC=13;
 47  
     public static final int ASK=14;
 48  
     public static final int ASTERISK=15;
 49  
     public static final int AVG=16;
 50  
     public static final int BASE=17;
 51  
     public static final int BIND=18;
 52  
     public static final int BINDINGS=19;
 53  
     public static final int BINDING_VALUE=20;
 54  
     public static final int BLANK_NODE=21;
 55  
     public static final int BLANK_NODE_LABEL=22;
 56  
     public static final int BNODE=23;
 57  
     public static final int BOUND=24;
 58  
     public static final int BRACKETTED_EXPRESSION=25;
 59  
     public static final int BY=26;
 60  
     public static final int CEIL=27;
 61  
     public static final int CLEAR=28;
 62  
     public static final int COALESCE=29;
 63  
     public static final int COLLECTION=30;
 64  
     public static final int COMMENT=31;
 65  
     public static final int CONCAT=32;
 66  
     public static final int CONSTRUCT=33;
 67  
     public static final int CONSTRUCT_TRIPLES=34;
 68  
     public static final int CONTAINS=35;
 69  
     public static final int COPY=36;
 70  
     public static final int COUNT=37;
 71  
     public static final int CREATE=38;
 72  
     public static final int DATA=39;
 73  
     public static final int DATATYPE=40;
 74  
     public static final int DAY=41;
 75  
     public static final int DECIMAL=42;
 76  
     public static final int DECIMAL_NEGATIVE=43;
 77  
     public static final int DECIMAL_POSITIVE=44;
 78  
     public static final int DEFAULT=45;
 79  
     public static final int DELETE=46;
 80  
     public static final int DESC=47;
 81  
     public static final int DESCRIBE=48;
 82  
     public static final int DIGIT=49;
 83  
     public static final int DISTINCT=50;
 84  
     public static final int DIVIDE=51;
 85  
     public static final int DOT=52;
 86  
     public static final int DOUBLE=53;
 87  
     public static final int DOUBLE_NEGATIVE=54;
 88  
     public static final int DOUBLE_POSITIVE=55;
 89  
     public static final int DROP=56;
 90  
     public static final int ECHAR=57;
 91  
     public static final int ENCODE_FOR_URI=58;
 92  
     public static final int EOL=59;
 93  
     public static final int EQUAL=60;
 94  
     public static final int EXISTS=61;
 95  
     public static final int EXPONENT=62;
 96  
     public static final int EXPRESSION_LIST=63;
 97  
     public static final int FALSE=64;
 98  
     public static final int FILTER=65;
 99  
     public static final int FLOOR=66;
 100  
     public static final int FROM=67;
 101  
     public static final int FUNCTION=68;
 102  
     public static final int GRAPH=69;
 103  
     public static final int GREATER=70;
 104  
     public static final int GREATER_EQUAL=71;
 105  
     public static final int GROUP=72;
 106  
     public static final int GROUP_BY=73;
 107  
     public static final int GROUP_CONCAT=74;
 108  
     public static final int GROUP_CONDITION=75;
 109  
     public static final int GROUP_GRAPH_PATTERN=76;
 110  
     public static final int HAVING=77;
 111  
     public static final int HEX=78;
 112  
     public static final int HOURS=79;
 113  
     public static final int IF=80;
 114  
     public static final int IN=81;
 115  
     public static final int INSERT=82;
 116  
     public static final int INTEGER=83;
 117  
     public static final int INTEGER_NEGATIVE=84;
 118  
     public static final int INTEGER_POSITIVE=85;
 119  
     public static final int INTO=86;
 120  
     public static final int INVERSE=87;
 121  
     public static final int IRI=88;
 122  
     public static final int IRI_REF=89;
 123  
     public static final int IRI_REF_CHARACTERS=90;
 124  
     public static final int ISBLANK=91;
 125  
     public static final int ISIRI=92;
 126  
     public static final int ISLITERAL=93;
 127  
     public static final int ISNUMERIC=94;
 128  
     public static final int ISURI=95;
 129  
     public static final int LANG=96;
 130  
     public static final int LANGMATCHES=97;
 131  
     public static final int LANGTAG=98;
 132  
     public static final int LCASE=99;
 133  
     public static final int LESS=100;
 134  
     public static final int LESS_EQUAL=101;
 135  
     public static final int LIMIT=102;
 136  
     public static final int LOAD=103;
 137  
     public static final int MAX=104;
 138  
     public static final int MD5=105;
 139  
     public static final int MIN=106;
 140  
     public static final int MINUS=107;
 141  
     public static final int MINUS_KEYWORD=108;
 142  
     public static final int MINUTES=109;
 143  
     public static final int MODIFY=110;
 144  
     public static final int MONTH=111;
 145  
     public static final int MOVE=112;
 146  
     public static final int NAMED=113;
 147  
     public static final int NEGATION=114;
 148  
     public static final int NIL=115;
 149  
     public static final int NOT=116;
 150  
     public static final int NOT_EQUAL=117;
 151  
     public static final int NOT_EXISTS=118;
 152  
     public static final int NOW=119;
 153  
     public static final int OBJECT=120;
 154  
     public static final int OFFSET=121;
 155  
     public static final int OPTIONAL=122;
 156  
     public static final int OR=123;
 157  
     public static final int ORDER=124;
 158  
     public static final int ORDER_BY=125;
 159  
     public static final int ORDER_CONDITION=126;
 160  
     public static final int PATH=127;
 161  
     public static final int PATH_ELT_OR_INVERSE=128;
 162  
     public static final int PATH_MOD=129;
 163  
     public static final int PATH_NEGATED=130;
 164  
     public static final int PATH_PRIMARY=131;
 165  
     public static final int PATH_SEQUENCE=132;
 166  
     public static final int PERCENT=133;
 167  
     public static final int PLUS=134;
 168  
     public static final int PLX=135;
 169  
     public static final int PNAME_LN=136;
 170  
     public static final int PNAME_NS=137;
 171  
     public static final int PN_CHARS=138;
 172  
     public static final int PN_CHARS_BASE=139;
 173  
     public static final int PN_CHARS_U=140;
 174  
     public static final int PN_LOCAL=141;
 175  
     public static final int PN_LOCAL_ESC=142;
 176  
     public static final int PN_PREFIX=143;
 177  
     public static final int PREDICATE=144;
 178  
     public static final int PREFIX=145;
 179  
     public static final int PROLOGUE=146;
 180  
     public static final int QUERY=147;
 181  
     public static final int QUESTION_MARK=148;
 182  
     public static final int RAND=149;
 183  
     public static final int RDFLITERAL=150;
 184  
     public static final int REDUCED=151;
 185  
     public static final int REGEX=152;
 186  
     public static final int REPLACE=153;
 187  
     public static final int ROUND=154;
 188  
     public static final int SAMETERM=155;
 189  
     public static final int SAMPLE=156;
 190  
     public static final int SECONDS=157;
 191  
     public static final int SELECT=158;
 192  
     public static final int SELECT_CLAUSE=159;
 193  
     public static final int SEPARATOR=160;
 194  
     public static final int SERVICE=161;
 195  
     public static final int SHA1=162;
 196  
     public static final int SHA224=163;
 197  
     public static final int SHA256=164;
 198  
     public static final int SHA384=165;
 199  
     public static final int SHA512=166;
 200  
     public static final int SIGN=167;
 201  
     public static final int SILENT=168;
 202  
     public static final int STR=169;
 203  
     public static final int STRAFTER=170;
 204  
     public static final int STRBEFORE=171;
 205  
     public static final int STRDT=172;
 206  
     public static final int STRENDS=173;
 207  
     public static final int STRING_LITERAL1=174;
 208  
     public static final int STRING_LITERAL2=175;
 209  
     public static final int STRING_LITERAL_LONG1=176;
 210  
     public static final int STRING_LITERAL_LONG2=177;
 211  
     public static final int STRLANG=178;
 212  
     public static final int STRLEN=179;
 213  
     public static final int STRSTARTS=180;
 214  
     public static final int SUBJECT=181;
 215  
     public static final int SUBSELECT=182;
 216  
     public static final int SUBSTR=183;
 217  
     public static final int SUM=184;
 218  
     public static final int TIMEZONE=185;
 219  
     public static final int TO=186;
 220  
     public static final int TRIPLES_BLOCK=187;
 221  
     public static final int TRIPLES_NODE=188;
 222  
     public static final int TRIPLES_SAME_SUBJECT=189;
 223  
     public static final int TRIPLES_TEMPLATE=190;
 224  
     public static final int TRUE=191;
 225  
     public static final int TZ=192;
 226  
     public static final int UCASE=193;
 227  
     public static final int UNARY=194;
 228  
     public static final int UNDEF=195;
 229  
     public static final int UNION=196;
 230  
     public static final int UPDATE=197;
 231  
     public static final int URI=198;
 232  
     public static final int USING=199;
 233  
     public static final int VAR=200;
 234  
     public static final int VAR1=201;
 235  
     public static final int VAR2=202;
 236  
     public static final int VARNAME=203;
 237  
     public static final int WHERE=204;
 238  
     public static final int WHERE_CLAUSE=205;
 239  
     public static final int WITH=206;
 240  
     public static final int WS=207;
 241  
     public static final int YEAR=208;
 242  
 
 243  
     // delegates
 244  
     public Parser[] getDelegates() {
 245  0
         return new Parser[] {};
 246  1958
     }
 247  1958
 
 248  
     // delegators
 249  1958
 
 250  1958
 
 251  
     public SparqlParser(TokenStream input) {
 252  9598
         this(input, new RecognizerSharedState());
 253  7640
     }
 254  
     public SparqlParser(TokenStream input, RecognizerSharedState state) {
 255  7640
         super(input, state);
 256  7640
     }
 257  
 
 258  7640
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 259  
 
 260  110
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 261  0
     this.adaptor = adaptor;
 262  0
 }
 263  
 public TreeAdaptor getTreeAdaptor() {
 264  1958
     return adaptor;
 265  
 }
 266  1958
     public String[] getTokenNames() { return SparqlParser.tokenNames; }
 267  0
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\Sparql.g"; }
 268  
 
 269  
 
 270  7640
     public static class query_return extends ParserRuleReturnScope {
 271  
         Object tree;
 272  7640
         public Object getTree() { return tree; }
 273  1958
     };
 274  1958
 
 275  
 
 276  
     // $ANTLR start "query"
 277  1958
     // com\\googlecode\\sparkleg\\Sparql.g:98:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( ';' ( update )? )* EOF -> ^( UPDATE ( update )+ ) );
 278  
     public final SparqlParser.query_return query() throws RecognitionException {
 279  9598
         SparqlParser.query_return retval = new SparqlParser.query_return();
 280  9598
         retval.start = input.LT(1);
 281  1958
 
 282  1958
 
 283  7640
         Object root_0 = null;
 284  1958
 
 285  7640
         Token EOF7=null;
 286  9598
         Token char_literal9=null;
 287  7640
         Token EOF11=null;
 288  9598
         SparqlParser.prologue_return prologue1 =null;
 289  
 
 290  9598
         SparqlParser.selectQuery_return selectQuery2 =null;
 291  
 
 292  9598
         SparqlParser.constructQuery_return constructQuery3 =null;
 293  
 
 294  9598
         SparqlParser.describeQuery_return describeQuery4 =null;
 295  
 
 296  9598
         SparqlParser.askQuery_return askQuery5 =null;
 297  
 
 298  7640
         SparqlParser.bindingsClause_return bindingsClause6 =null;
 299  1958
 
 300  9598
         SparqlParser.update_return update8 =null;
 301  1958
 
 302  9598
         SparqlParser.update_return update10 =null;
 303  1958
 
 304  1958
 
 305  9598
         Object EOF7_tree=null;
 306  9598
         Object char_literal9_tree=null;
 307  9598
         Object EOF11_tree=null;
 308  9598
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 309  9598
         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 310  9598
         RewriteRuleSubtreeStream stream_update=new RewriteRuleSubtreeStream(adaptor,"rule update");
 311  7640
         RewriteRuleSubtreeStream stream_describeQuery=new RewriteRuleSubtreeStream(adaptor,"rule describeQuery");
 312  7640
         RewriteRuleSubtreeStream stream_bindingsClause=new RewriteRuleSubtreeStream(adaptor,"rule bindingsClause");
 313  9598
         RewriteRuleSubtreeStream stream_constructQuery=new RewriteRuleSubtreeStream(adaptor,"rule constructQuery");
 314  9598
         RewriteRuleSubtreeStream stream_askQuery=new RewriteRuleSubtreeStream(adaptor,"rule askQuery");
 315  9598
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 316  7640
         RewriteRuleSubtreeStream stream_selectQuery=new RewriteRuleSubtreeStream(adaptor,"rule selectQuery");
 317  
         try {
 318  
             // com\\googlecode\\sparkleg\\Sparql.g:99:5: ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( ';' ( update )? )* EOF -> ^( UPDATE ( update )+ ) )
 319  9474
             int alt4=2;
 320  9474
             alt4 = dfa4.predict(input);
 321  7640
             switch (alt4) {
 322  1834
                 case 1 :
 323  
                     // com\\googlecode\\sparkleg\\Sparql.g:99:7: prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF
 324  1834
                     {
 325  7144
                     pushFollow(FOLLOW_prologue_in_query251);
 326  7144
                     prologue1=prologue();
 327  1834
 
 328  8978
                     state._fsp--;
 329  
 
 330  7144
                     stream_prologue.add(prologue1.getTree());
 331  1614
 
 332  
                     // com\\googlecode\\sparkleg\\Sparql.g:99:16: ( selectQuery | constructQuery | describeQuery | askQuery )
 333  8758
                     int alt1=4;
 334  7144
                     switch ( input.LA(1) ) {
 335  
                     case SELECT:
 336  72
                         {
 337  6276
                         alt1=1;
 338  72
                         }
 339  6276
                         break;
 340  
                     case CONSTRUCT:
 341  28
                         {
 342  270
                         alt1=2;
 343  28
                         }
 344  270
                         break;
 345  
                     case DESCRIBE:
 346  120
                         {
 347  112
                         alt1=3;
 348  120
                         }
 349  112
                         break;
 350  
                     case ASK:
 351  
                         {
 352  486
                         alt1=4;
 353  
                         }
 354  486
                         break;
 355  
                     default:
 356  0
                         NoViableAltException nvae =
 357  1834
                             new NoViableAltException("", 1, 0, input);
 358  
 
 359  0
                         throw nvae;
 360  
 
 361  1614
                     }
 362  1614
 
 363  7144
                     switch (alt1) {
 364  1614
                         case 1 :
 365  
                             // com\\googlecode\\sparkleg\\Sparql.g:99:17: selectQuery
 366  1614
                             {
 367  6276
                             pushFollow(FOLLOW_selectQuery_in_query254);
 368  6276
                             selectQuery2=selectQuery();
 369  1614
 
 370  6276
                             state._fsp--;
 371  
 
 372  6276
                             stream_selectQuery.add(selectQuery2.getTree());
 373  72
 
 374  72
                             }
 375  6276
                             break;
 376  72
                         case 2 :
 377  
                             // com\\googlecode\\sparkleg\\Sparql.g:99:31: constructQuery
 378  72
                             {
 379  270
                             pushFollow(FOLLOW_constructQuery_in_query258);
 380  270
                             constructQuery3=constructQuery();
 381  72
 
 382  270
                             state._fsp--;
 383  
 
 384  270
                             stream_constructQuery.add(constructQuery3.getTree());
 385  28
 
 386  28
                             }
 387  270
                             break;
 388  28
                         case 3 :
 389  
                             // com\\googlecode\\sparkleg\\Sparql.g:99:48: describeQuery
 390  28
                             {
 391  112
                             pushFollow(FOLLOW_describeQuery_in_query262);
 392  112
                             describeQuery4=describeQuery();
 393  28
 
 394  112
                             state._fsp--;
 395  
 
 396  112
                             stream_describeQuery.add(describeQuery4.getTree());
 397  120
 
 398  120
                             }
 399  112
                             break;
 400  120
                         case 4 :
 401  
                             // com\\googlecode\\sparkleg\\Sparql.g:99:64: askQuery
 402  120
                             {
 403  486
                             pushFollow(FOLLOW_askQuery_in_query266);
 404  486
                             askQuery5=askQuery();
 405  
 
 406  486
                             state._fsp--;
 407  
 
 408  486
                             stream_askQuery.add(askQuery5.getTree());
 409  
 
 410  1834
                             }
 411  1834
                             break;
 412  
 
 413  1834
                     }
 414  
 
 415  1834
 
 416  7144
                     pushFollow(FOLLOW_bindingsClause_in_query269);
 417  8978
                     bindingsClause6=bindingsClause();
 418  1834
 
 419  7144
                     state._fsp--;
 420  
 
 421  7144
                     stream_bindingsClause.add(bindingsClause6.getTree());
 422  
 
 423  7144
                     EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_query271);  
 424  7144
                     stream_EOF.add(EOF7);
 425  
 
 426  
 
 427  
                     // AST REWRITE
 428  1834
                     // elements: selectQuery, describeQuery, constructQuery, askQuery, bindingsClause, prologue
 429  1834
                     // token labels: 
 430  
                     // rule labels: retval
 431  1834
                     // token list labels: 
 432  
                     // rule list labels: 
 433  
                     // wildcard labels: 
 434  7144
                     retval.tree = root_0;
 435  7144
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 436  1834
 
 437  8978
                     root_0 = (Object)adaptor.nil();
 438  
                     // 99:93: -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )*
 439  
                     {
 440  
                         // com\\googlecode\\sparkleg\\Sparql.g:99:96: ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* )
 441  1834
                         {
 442  7144
                         Object root_1 = (Object)adaptor.nil();
 443  7144
                         root_1 = (Object)adaptor.becomeRoot(
 444  3448
                         (Object)adaptor.create(QUERY, "QUERY")
 445  1614
                         , root_1);
 446  
 
 447  7144
                         adaptor.addChild(root_1, stream_prologue.nextTree());
 448  1834
 
 449  
                         // com\\googlecode\\sparkleg\\Sparql.g:99:113: ( selectQuery )*
 450  13420
                         while ( stream_selectQuery.hasNext() ) {
 451  8182
                             adaptor.addChild(root_1, stream_selectQuery.nextTree());
 452  72
 
 453  
                         }
 454  7144
                         stream_selectQuery.reset();
 455  1834
 
 456  
                         // com\\googlecode\\sparkleg\\Sparql.g:99:126: ( constructQuery )*
 457  7414
                         while ( stream_constructQuery.hasNext() ) {
 458  2132
                             adaptor.addChild(root_1, stream_constructQuery.nextTree());
 459  28
 
 460  
                         }
 461  7144
                         stream_constructQuery.reset();
 462  1834
 
 463  
                         // com\\googlecode\\sparkleg\\Sparql.g:99:142: ( describeQuery )*
 464  7256
                         while ( stream_describeQuery.hasNext() ) {
 465  2066
                             adaptor.addChild(root_1, stream_describeQuery.nextTree());
 466  120
 
 467  
                         }
 468  7144
                         stream_describeQuery.reset();
 469  1834
 
 470  
                         // com\\googlecode\\sparkleg\\Sparql.g:99:157: ( askQuery )*
 471  9464
                         while ( stream_askQuery.hasNext() ) {
 472  486
                             adaptor.addChild(root_1, stream_askQuery.nextTree());
 473  
 
 474  
                         }
 475  9004
                         stream_askQuery.reset();
 476  26
 
 477  7144
                         adaptor.addChild(root_0, root_1);
 478  
                         }
 479  1834
 
 480  
                         // com\\googlecode\\sparkleg\\Sparql.g:99:168: ( bindingsClause )*
 481  7248
                         while ( stream_bindingsClause.hasNext() ) {
 482  104
                             adaptor.addChild(root_0, stream_bindingsClause.nextTree());
 483  
 
 484  1834
                         }
 485  7144
                         stream_bindingsClause.reset();
 486  
 
 487  1834
                     }
 488  
 
 489  
 
 490  7144
                     retval.tree = root_0;
 491  124
 
 492  124
                     }
 493  7144
                     break;
 494  124
                 case 2 :
 495  
                     // com\\googlecode\\sparkleg\\Sparql.g:100:7: update ( ';' ( update )? )* EOF
 496  124
                     {
 497  496
                     pushFollow(FOLLOW_update_in_query302);
 498  496
                     update8=update();
 499  
 
 500  496
                     state._fsp--;
 501  128
 
 502  624
                     stream_update.add(update8.getTree());
 503  
 
 504  
                     // com\\googlecode\\sparkleg\\Sparql.g:100:14: ( ';' ( update )? )*
 505  4
                     loop3:
 506  
                     do {
 507  512
                         int alt3=2;
 508  512
                         switch ( input.LA(1) ) {
 509  
                         case 212:
 510  
                             {
 511  144
                             alt3=1;
 512  
                             }
 513  
                             break;
 514  
 
 515  4
                         }
 516  4
 
 517  512
                         switch (alt3) {
 518  
                             case 1 :
 519  
                                 // com\\googlecode\\sparkleg\\Sparql.g:100:15: ';' ( update )?
 520  4
                                 {
 521  20
                                 char_literal9=(Token)match(input,212,FOLLOW_212_in_query305);  
 522  16
                                 stream_212.add(char_literal9);
 523  
 
 524  
 
 525  
                                 // com\\googlecode\\sparkleg\\Sparql.g:100:19: ( update )?
 526  16
                                 int alt2=2;
 527  16
                                 switch ( input.LA(1) ) {
 528  
                                     case ADD:
 529  
                                     case ASK:
 530  
                                     case BASE:
 531  
                                     case CLEAR:
 532  
                                     case CONSTRUCT:
 533  
                                     case COPY:
 534  
                                     case CREATE:
 535  
                                     case DELETE:
 536  
                                     case DESCRIBE:
 537  
                                     case DROP:
 538  
                                     case INSERT:
 539  4
                                     case LOAD:
 540  
                                     case MOVE:
 541  
                                     case PREFIX:
 542  
                                     case SELECT:
 543  
                                     case WITH:
 544  4
                                         {
 545  16
                                         alt2=1;
 546  
                                         }
 547  
                                         break;
 548  4
                                 }
 549  4
 
 550  16
                                 switch (alt2) {
 551  4
                                     case 1 :
 552  
                                         // com\\googlecode\\sparkleg\\Sparql.g:100:19: update
 553  4
                                         {
 554  16
                                         pushFollow(FOLLOW_update_in_query307);
 555  16
                                         update10=update();
 556  
 
 557  16
                                         state._fsp--;
 558  
 
 559  16
                                         stream_update.add(update10.getTree());
 560  
 
 561  
                                         }
 562  4
                                         break;
 563  
 
 564  
                                 }
 565  124
 
 566  
 
 567  4
                                 }
 568  16
                                 break;
 569  
 
 570  124
                             default :
 571  620
                                 break loop3;
 572  
                         }
 573  16
                     } while (true);
 574  
 
 575  
 
 576  496
                     EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_query312);  
 577  496
                     stream_EOF.add(EOF11);
 578  
 
 579  
 
 580  
                     // AST REWRITE
 581  124
                     // elements: update
 582  124
                     // token labels: 
 583  
                     // rule labels: retval
 584  124
                     // token list labels: 
 585  
                     // rule list labels: 
 586  
                     // wildcard labels: 
 587  496
                     retval.tree = root_0;
 588  496
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 589  124
 
 590  620
                     root_0 = (Object)adaptor.nil();
 591  
                     // 100:33: -> ^( UPDATE ( update )+ )
 592  
                     {
 593  
                         // com\\googlecode\\sparkleg\\Sparql.g:100:36: ^( UPDATE ( update )+ )
 594  124
                         {
 595  496
                         Object root_1 = (Object)adaptor.nil();
 596  496
                         root_1 = (Object)adaptor.becomeRoot(
 597  252
                         (Object)adaptor.create(UPDATE, "UPDATE")
 598  128
                         , root_1);
 599  
 
 600  496
                         if ( !(stream_update.hasNext()) ) {
 601  124
                             throw new RewriteEarlyExitException();
 602  
                         }
 603  1132
                         while ( stream_update.hasNext() ) {
 604  512
                             adaptor.addChild(root_1, stream_update.nextTree());
 605  
 
 606  
                         }
 607  496
                         stream_update.reset();
 608  
 
 609  620
                         adaptor.addChild(root_0, root_1);
 610  
                         }
 611  
 
 612  
                     }
 613  
 
 614  
 
 615  2454
                     retval.tree = root_0;
 616  
 
 617  
                     }
 618  1958
                     break;
 619  1958
 
 620  
             }
 621  7640
             retval.stop = input.LT(-1);
 622  
 
 623  
 
 624  7640
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 625  7640
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 626  
 
 627  
         }
 628  0
         catch (RecognitionException re) {
 629  0
             reportError(re);
 630  0
             recover(input,re);
 631  1958
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 632  1958
 
 633  
         }
 634  
 
 635  0
         finally {
 636  
                 // do for sure before leaving
 637  7640
         }
 638  7640
         return retval;
 639  1962
     }
 640  
     // $ANTLR end "query"
 641  
 
 642  
 
 643  7656
     public static class prologue_return extends ParserRuleReturnScope {
 644  
         Object tree;
 645  7656
         public Object getTree() { return tree; }
 646  1962
     };
 647  1962
 
 648  
 
 649  
     // $ANTLR start "prologue"
 650  1962
     // com\\googlecode\\sparkleg\\Sparql.g:103:1: prologue : ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 651  
     public final SparqlParser.prologue_return prologue() throws RecognitionException {
 652  9618
         SparqlParser.prologue_return retval = new SparqlParser.prologue_return();
 653  7656
         retval.start = input.LT(1);
 654  1962
 
 655  
 
 656  7656
         Object root_0 = null;
 657  1962
 
 658  9618
         SparqlParser.baseDecl_return baseDecl12 =null;
 659  
 
 660  7656
         SparqlParser.prefixDecl_return prefixDecl13 =null;
 661  
 
 662  
 
 663  7656
         RewriteRuleSubtreeStream stream_prefixDecl=new RewriteRuleSubtreeStream(adaptor,"rule prefixDecl");
 664  7656
         RewriteRuleSubtreeStream stream_baseDecl=new RewriteRuleSubtreeStream(adaptor,"rule baseDecl");
 665  
         try {
 666  4814
             // com\\googlecode\\sparkleg\\Sparql.g:105:5: ( ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 667  4814
             // com\\googlecode\\sparkleg\\Sparql.g:105:7: ( baseDecl | prefixDecl )*
 668  
             {
 669  
             // com\\googlecode\\sparkleg\\Sparql.g:105:7: ( baseDecl | prefixDecl )*
 670  62
             loop5:
 671  
             do {
 672  19096
                 int alt5=3;
 673  19034
                 switch ( input.LA(1) ) {
 674  
                 case BASE:
 675  2790
                     {
 676  248
                     alt5=1;
 677  
                     }
 678  248
                     break;
 679  
                 case PREFIX:
 680  
                     {
 681  15944
                     alt5=2;
 682  
                     }
 683  
                     break;
 684  
 
 685  62
                 }
 686  62
 
 687  19034
                 switch (alt5) {
 688  62
                     case 1 :
 689  
                         // com\\googlecode\\sparkleg\\Sparql.g:105:8: baseDecl
 690  62
                         {
 691  248
                         pushFollow(FOLLOW_baseDecl_in_prologue345);
 692  248
                         baseDecl12=baseDecl();
 693  62
 
 694  248
                         state._fsp--;
 695  
 
 696  248
                         stream_baseDecl.add(baseDecl12.getTree());
 697  2790
 
 698  2790
                         }
 699  248
                         break;
 700  2790
                     case 2 :
 701  
                         // com\\googlecode\\sparkleg\\Sparql.g:105:19: prefixDecl
 702  2790
                         {
 703  11130
                         pushFollow(FOLLOW_prefixDecl_in_prologue349);
 704  11130
                         prefixDecl13=prefixDecl();
 705  2790
 
 706  11130
                         state._fsp--;
 707  
 
 708  13092
                         stream_prefixDecl.add(prefixDecl13.getTree());
 709  
 
 710  2852
                         }
 711  11130
                         break;
 712  
 
 713  
                     default :
 714  7656
                         break loop5;
 715  
                 }
 716  11378
             } while (true);
 717  
 
 718  
 
 719  
             // AST REWRITE
 720  1962
             // elements: baseDecl, prefixDecl
 721  1962
             // token labels: 
 722  
             // rule labels: retval
 723  1962
             // token list labels: 
 724  
             // rule list labels: 
 725  
             // wildcard labels: 
 726  7656
             retval.tree = root_0;
 727  7656
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 728  1962
 
 729  9618
             root_0 = (Object)adaptor.nil();
 730  
             // 105:32: -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 731  
             {
 732  
                 // com\\googlecode\\sparkleg\\Sparql.g:105:35: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 733  
                 {
 734  9680
                 Object root_1 = (Object)adaptor.nil();
 735  7718
                 root_1 = (Object)adaptor.becomeRoot(
 736  
                 (Object)adaptor.create(PROLOGUE, "PROLOGUE")
 737  
                 , root_1);
 738  1962
 
 739  
                 // com\\googlecode\\sparkleg\\Sparql.g:105:46: ( baseDecl )*
 740  7904
                 while ( stream_baseDecl.hasNext() ) {
 741  5000
                     adaptor.addChild(root_1, stream_baseDecl.nextTree());
 742  2790
 
 743  
                 }
 744  7656
                 stream_baseDecl.reset();
 745  1962
 
 746  
                 // com\\googlecode\\sparkleg\\Sparql.g:105:56: ( prefixDecl )*
 747  20748
                 while ( stream_prefixDecl.hasNext() ) {
 748  11130
                     adaptor.addChild(root_1, stream_prefixDecl.nextTree());
 749  
 
 750  
                 }
 751  7656
                 stream_prefixDecl.reset();
 752  
 
 753  9618
                 adaptor.addChild(root_0, root_1);
 754  
                 }
 755  
 
 756  
             }
 757  1962
 
 758  
 
 759  7656
             retval.tree = root_0;
 760  1962
 
 761  1962
             }
 762  
 
 763  7656
             retval.stop = input.LT(-1);
 764  
 
 765  
 
 766  7656
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 767  7656
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 768  
 
 769  
         }
 770  0
         catch (RecognitionException re) {
 771  0
             reportError(re);
 772  0
             recover(input,re);
 773  1962
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 774  1962
 
 775  
         }
 776  
 
 777  0
         finally {
 778  
                 // do for sure before leaving
 779  62
         }
 780  7656
         return retval;
 781  62
     }
 782  
     // $ANTLR end "prologue"
 783  
 
 784  
 
 785  248
     public static class baseDecl_return extends ParserRuleReturnScope {
 786  
         Object tree;
 787  248
         public Object getTree() { return tree; }
 788  62
     };
 789  62
 
 790  
 
 791  
     // $ANTLR start "baseDecl"
 792  62
     // com\\googlecode\\sparkleg\\Sparql.g:108:1: baseDecl : BASE IRI_REF -> ^( BASE IRI_REF ) ;
 793  
     public final SparqlParser.baseDecl_return baseDecl() throws RecognitionException {
 794  310
         SparqlParser.baseDecl_return retval = new SparqlParser.baseDecl_return();
 795  310
         retval.start = input.LT(1);
 796  
 
 797  62
 
 798  310
         Object root_0 = null;
 799  62
 
 800  310
         Token BASE14=null;
 801  248
         Token IRI_REF15=null;
 802  
 
 803  248
         Object BASE14_tree=null;
 804  248
         Object IRI_REF15_tree=null;
 805  248
         RewriteRuleTokenStream stream_BASE=new RewriteRuleTokenStream(adaptor,"token BASE");
 806  310
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 807  62
 
 808  
         try {
 809  
             // com\\googlecode\\sparkleg\\Sparql.g:109:5: ( BASE IRI_REF -> ^( BASE IRI_REF ) )
 810  62
             // com\\googlecode\\sparkleg\\Sparql.g:109:7: BASE IRI_REF
 811  62
             {
 812  248
             BASE14=(Token)match(input,BASE,FOLLOW_BASE_in_baseDecl380);  
 813  248
             stream_BASE.add(BASE14);
 814  
 
 815  
 
 816  248
             IRI_REF15=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl382);  
 817  248
             stream_IRI_REF.add(IRI_REF15);
 818  
 
 819  
 
 820  
             // AST REWRITE
 821  62
             // elements: IRI_REF, BASE
 822  62
             // token labels: 
 823  
             // rule labels: retval
 824  62
             // token list labels: 
 825  
             // rule list labels: 
 826  
             // wildcard labels: 
 827  248
             retval.tree = root_0;
 828  248
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 829  62
 
 830  310
             root_0 = (Object)adaptor.nil();
 831  
             // 109:20: -> ^( BASE IRI_REF )
 832  
             {
 833  
                 // com\\googlecode\\sparkleg\\Sparql.g:109:23: ^( BASE IRI_REF )
 834  62
                 {
 835  248
                 Object root_1 = (Object)adaptor.nil();
 836  248
                 root_1 = (Object)adaptor.becomeRoot(
 837  
                 stream_BASE.nextNode()
 838  62
                 , root_1);
 839  
 
 840  248
                 adaptor.addChild(root_1, 
 841  
                 stream_IRI_REF.nextNode()
 842  
                 );
 843  
 
 844  310
                 adaptor.addChild(root_0, root_1);
 845  
                 }
 846  
 
 847  
             }
 848  62
 
 849  
 
 850  248
             retval.tree = root_0;
 851  62
 
 852  62
             }
 853  
 
 854  248
             retval.stop = input.LT(-1);
 855  
 
 856  
 
 857  248
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 858  248
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 859  
 
 860  
         }
 861  0
         catch (RecognitionException re) {
 862  0
             reportError(re);
 863  0
             recover(input,re);
 864  62
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 865  62
 
 866  
         }
 867  
 
 868  0
         finally {
 869  
                 // do for sure before leaving
 870  248
         }
 871  248
         return retval;
 872  2790
     }
 873  
     // $ANTLR end "baseDecl"
 874  
 
 875  
 
 876  11130
     public static class prefixDecl_return extends ParserRuleReturnScope {
 877  
         Object tree;
 878  11130
         public Object getTree() { return tree; }
 879  2790
     };
 880  2790
 
 881  
 
 882  
     // $ANTLR start "prefixDecl"
 883  2790
     // com\\googlecode\\sparkleg\\Sparql.g:112:1: prefixDecl : PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) ;
 884  
     public final SparqlParser.prefixDecl_return prefixDecl() throws RecognitionException {
 885  13920
         SparqlParser.prefixDecl_return retval = new SparqlParser.prefixDecl_return();
 886  13920
         retval.start = input.LT(1);
 887  2790
 
 888  
 
 889  13920
         Object root_0 = null;
 890  2790
 
 891  13920
         Token PREFIX16=null;
 892  13920
         Token PNAME_NS17=null;
 893  13920
         Token IRI_REF18=null;
 894  2790
 
 895  11130
         Object PREFIX16_tree=null;
 896  11130
         Object PNAME_NS17_tree=null;
 897  11130
         Object IRI_REF18_tree=null;
 898  11130
         RewriteRuleTokenStream stream_PREFIX=new RewriteRuleTokenStream(adaptor,"token PREFIX");
 899  11130
         RewriteRuleTokenStream stream_PNAME_NS=new RewriteRuleTokenStream(adaptor,"token PNAME_NS");
 900  13920
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 901  2790
 
 902  
         try {
 903  
             // com\\googlecode\\sparkleg\\Sparql.g:113:5: ( PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) )
 904  2790
             // com\\googlecode\\sparkleg\\Sparql.g:113:7: PREFIX PNAME_NS IRI_REF
 905  2790
             {
 906  11130
             PREFIX16=(Token)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl408);  
 907  11130
             stream_PREFIX.add(PREFIX16);
 908  2790
 
 909  2790
 
 910  11130
             PNAME_NS17=(Token)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl410);  
 911  11130
             stream_PNAME_NS.add(PNAME_NS17);
 912  
 
 913  
 
 914  11130
             IRI_REF18=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl412);  
 915  11130
             stream_IRI_REF.add(IRI_REF18);
 916  
 
 917  
 
 918  
             // AST REWRITE
 919  2790
             // elements: PNAME_NS, IRI_REF, PREFIX
 920  2790
             // token labels: 
 921  
             // rule labels: retval
 922  2790
             // token list labels: 
 923  
             // rule list labels: 
 924  
             // wildcard labels: 
 925  11130
             retval.tree = root_0;
 926  11130
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 927  2790
 
 928  13920
             root_0 = (Object)adaptor.nil();
 929  
             // 113:31: -> ^( PREFIX PNAME_NS IRI_REF )
 930  
             {
 931  
                 // com\\googlecode\\sparkleg\\Sparql.g:113:34: ^( PREFIX PNAME_NS IRI_REF )
 932  2790
                 {
 933  11130
                 Object root_1 = (Object)adaptor.nil();
 934  11130
                 root_1 = (Object)adaptor.becomeRoot(
 935  
                 stream_PREFIX.nextNode()
 936  2790
                 , root_1);
 937  
 
 938  11130
                 adaptor.addChild(root_1, 
 939  
                 stream_PNAME_NS.nextNode()
 940  2790
                 );
 941  
 
 942  11130
                 adaptor.addChild(root_1, 
 943  
                 stream_IRI_REF.nextNode()
 944  
                 );
 945  
 
 946  13920
                 adaptor.addChild(root_0, root_1);
 947  
                 }
 948  
 
 949  
             }
 950  2790
 
 951  
 
 952  11130
             retval.tree = root_0;
 953  2790
 
 954  2790
             }
 955  
 
 956  11130
             retval.stop = input.LT(-1);
 957  
 
 958  
 
 959  11130
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 960  11130
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 961  
 
 962  
         }
 963  0
         catch (RecognitionException re) {
 964  0
             reportError(re);
 965  0
             recover(input,re);
 966  2790
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 967  2790
 
 968  
         }
 969  
 
 970  0
         finally {
 971  
                 // do for sure before leaving
 972  11130
         }
 973  11130
         return retval;
 974  1614
     }
 975  
     // $ANTLR end "prefixDecl"
 976  
 
 977  
 
 978  6276
     public static class selectQuery_return extends ParserRuleReturnScope {
 979  
         Object tree;
 980  6276
         public Object getTree() { return tree; }
 981  1614
     };
 982  1614
 
 983  
 
 984  
     // $ANTLR start "selectQuery"
 985  1614
     // com\\googlecode\\sparkleg\\Sparql.g:116:1: selectQuery : selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) ;
 986  
     public final SparqlParser.selectQuery_return selectQuery() throws RecognitionException {
 987  7890
         SparqlParser.selectQuery_return retval = new SparqlParser.selectQuery_return();
 988  6276
         retval.start = input.LT(1);
 989  1614
 
 990  
 
 991  7890
         Object root_0 = null;
 992  
 
 993  7890
         SparqlParser.selectClause_return selectClause19 =null;
 994  
 
 995  6276
         SparqlParser.datasetClause_return datasetClause20 =null;
 996  1614
 
 997  7890
         SparqlParser.whereClause_return whereClause21 =null;
 998  1614
 
 999  7890
         SparqlParser.solutionModifier_return solutionModifier22 =null;
 1000  
 
 1001  
 
 1002  6276
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1003  6276
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1004  7890
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1005  7890
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1006  
         try {
 1007  1614
             // com\\googlecode\\sparkleg\\Sparql.g:117:5: ( selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) )
 1008  
             // com\\googlecode\\sparkleg\\Sparql.g:117:7: selectClause ( datasetClause )* whereClause solutionModifier
 1009  1614
             {
 1010  6276
             pushFollow(FOLLOW_selectClause_in_selectQuery439);
 1011  6276
             selectClause19=selectClause();
 1012  
 
 1013  6276
             state._fsp--;
 1014  1772
 
 1015  8048
             stream_selectClause.add(selectClause19.getTree());
 1016  
 
 1017  
             // com\\googlecode\\sparkleg\\Sparql.g:117:20: ( datasetClause )*
 1018  158
             loop6:
 1019  
             do {
 1020  6908
                 int alt6=2;
 1021  6908
                 switch ( input.LA(1) ) {
 1022  
                 case FROM:
 1023  
                     {
 1024  2404
                     alt6=1;
 1025  
                     }
 1026  
                     break;
 1027  
 
 1028  158
                 }
 1029  158
 
 1030  6908
                 switch (alt6) {
 1031  158
                     case 1 :
 1032  
                         // com\\googlecode\\sparkleg\\Sparql.g:117:20: datasetClause
 1033  158
                         {
 1034  632
                         pushFollow(FOLLOW_datasetClause_in_selectQuery441);
 1035  632
                         datasetClause20=datasetClause();
 1036  158
 
 1037  632
                         state._fsp--;
 1038  
 
 1039  2246
                         stream_datasetClause.add(datasetClause20.getTree());
 1040  
 
 1041  158
                         }
 1042  632
                         break;
 1043  
 
 1044  1614
                     default :
 1045  7890
                         break loop6;
 1046  
                 }
 1047  2246
             } while (true);
 1048  
 
 1049  1614
 
 1050  6276
             pushFollow(FOLLOW_whereClause_in_selectQuery444);
 1051  7890
             whereClause21=whereClause();
 1052  1614
 
 1053  6276
             state._fsp--;
 1054  1614
 
 1055  6276
             stream_whereClause.add(whereClause21.getTree());
 1056  1614
 
 1057  6276
             pushFollow(FOLLOW_solutionModifier_in_selectQuery446);
 1058  6276
             solutionModifier22=solutionModifier();
 1059  
 
 1060  6276
             state._fsp--;
 1061  
 
 1062  6276
             stream_solutionModifier.add(solutionModifier22.getTree());
 1063  
 
 1064  
             // AST REWRITE
 1065  1614
             // elements: datasetClause, selectClause, solutionModifier, whereClause
 1066  1614
             // token labels: 
 1067  
             // rule labels: retval
 1068  1614
             // token list labels: 
 1069  
             // rule list labels: 
 1070  
             // wildcard labels: 
 1071  6276
             retval.tree = root_0;
 1072  6276
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1073  1614
 
 1074  7890
             root_0 = (Object)adaptor.nil();
 1075  
             // 117:64: -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1076  
             {
 1077  
                 // com\\googlecode\\sparkleg\\Sparql.g:117:67: ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1078  1614
                 {
 1079  6276
                 Object root_1 = (Object)adaptor.nil();
 1080  6276
                 root_1 = (Object)adaptor.becomeRoot(
 1081  1772
                 (Object)adaptor.create(SELECT, "SELECT")
 1082  158
                 , root_1);
 1083  
 
 1084  6276
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1085  1614
 
 1086  
                 // com\\googlecode\\sparkleg\\Sparql.g:117:89: ( datasetClause )*
 1087  6908
                 while ( stream_datasetClause.hasNext() ) {
 1088  3860
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1089  1614
 
 1090  
                 }
 1091  6276
                 stream_datasetClause.reset();
 1092  1614
 
 1093  
                 // com\\googlecode\\sparkleg\\Sparql.g:117:104: ( whereClause )*
 1094  12552
                 while ( stream_whereClause.hasNext() ) {
 1095  8078
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1096  188
 
 1097  
                 }
 1098  6276
                 stream_whereClause.reset();
 1099  1614
 
 1100  
                 // com\\googlecode\\sparkleg\\Sparql.g:117:117: ( solutionModifier )*
 1101  8642
                 while ( stream_solutionModifier.hasNext() ) {
 1102  752
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1103  
 
 1104  
                 }
 1105  6276
                 stream_solutionModifier.reset();
 1106  
 
 1107  7890
                 adaptor.addChild(root_0, root_1);
 1108  
                 }
 1109  
 
 1110  
             }
 1111  1614
 
 1112  
 
 1113  6276
             retval.tree = root_0;
 1114  1614
 
 1115  1614
             }
 1116  
 
 1117  6276
             retval.stop = input.LT(-1);
 1118  
 
 1119  
 
 1120  6276
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1121  6276
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1122  
 
 1123  
         }
 1124  0
         catch (RecognitionException re) {
 1125  0
             reportError(re);
 1126  0
             recover(input,re);
 1127  1614
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1128  1614
 
 1129  
         }
 1130  
 
 1131  0
         finally {
 1132  
                 // do for sure before leaving
 1133  46
         }
 1134  6276
         return retval;
 1135  46
     }
 1136  
     // $ANTLR end "selectQuery"
 1137  
 
 1138  
 
 1139  184
     public static class subSelect_return extends ParserRuleReturnScope {
 1140  
         Object tree;
 1141  184
         public Object getTree() { return tree; }
 1142  46
     };
 1143  46
 
 1144  
 
 1145  
     // $ANTLR start "subSelect"
 1146  46
     // com\\googlecode\\sparkleg\\Sparql.g:120:1: subSelect : selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) ;
 1147  
     public final SparqlParser.subSelect_return subSelect() throws RecognitionException {
 1148  230
         SparqlParser.subSelect_return retval = new SparqlParser.subSelect_return();
 1149  184
         retval.start = input.LT(1);
 1150  46
 
 1151  
 
 1152  230
         Object root_0 = null;
 1153  
 
 1154  184
         SparqlParser.selectClause_return selectClause23 =null;
 1155  46
 
 1156  230
         SparqlParser.whereClause_return whereClause24 =null;
 1157  46
 
 1158  184
         SparqlParser.solutionModifier_return solutionModifier25 =null;
 1159  
 
 1160  
 
 1161  184
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1162  230
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1163  230
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1164  
         try {
 1165  46
             // com\\googlecode\\sparkleg\\Sparql.g:121:5: ( selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) )
 1166  
             // com\\googlecode\\sparkleg\\Sparql.g:121:7: selectClause whereClause solutionModifier
 1167  46
             {
 1168  184
             pushFollow(FOLLOW_selectClause_in_subSelect480);
 1169  230
             selectClause23=selectClause();
 1170  46
 
 1171  184
             state._fsp--;
 1172  46
 
 1173  184
             stream_selectClause.add(selectClause23.getTree());
 1174  46
 
 1175  184
             pushFollow(FOLLOW_whereClause_in_subSelect482);
 1176  230
             whereClause24=whereClause();
 1177  46
 
 1178  184
             state._fsp--;
 1179  46
 
 1180  184
             stream_whereClause.add(whereClause24.getTree());
 1181  46
 
 1182  184
             pushFollow(FOLLOW_solutionModifier_in_subSelect484);
 1183  184
             solutionModifier25=solutionModifier();
 1184  
 
 1185  184
             state._fsp--;
 1186  
 
 1187  184
             stream_solutionModifier.add(solutionModifier25.getTree());
 1188  
 
 1189  
             // AST REWRITE
 1190  46
             // elements: whereClause, selectClause, solutionModifier
 1191  46
             // token labels: 
 1192  
             // rule labels: retval
 1193  46
             // token list labels: 
 1194  
             // rule list labels: 
 1195  
             // wildcard labels: 
 1196  184
             retval.tree = root_0;
 1197  184
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1198  46
 
 1199  230
             root_0 = (Object)adaptor.nil();
 1200  
             // 121:49: -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1201  
             {
 1202  
                 // com\\googlecode\\sparkleg\\Sparql.g:121:52: ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1203  46
                 {
 1204  184
                 Object root_1 = (Object)adaptor.nil();
 1205  184
                 root_1 = (Object)adaptor.becomeRoot(
 1206  92
                 (Object)adaptor.create(SUBSELECT, "SUBSELECT")
 1207  46
                 , root_1);
 1208  
 
 1209  184
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1210  46
 
 1211  
                 // com\\googlecode\\sparkleg\\Sparql.g:121:77: ( whereClause )*
 1212  368
                 while ( stream_whereClause.hasNext() ) {
 1213  240
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1214  10
 
 1215  
                 }
 1216  184
                 stream_whereClause.reset();
 1217  46
 
 1218  
                 // com\\googlecode\\sparkleg\\Sparql.g:121:90: ( solutionModifier )*
 1219  270
                 while ( stream_solutionModifier.hasNext() ) {
 1220  40
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1221  
 
 1222  
                 }
 1223  184
                 stream_solutionModifier.reset();
 1224  
 
 1225  230
                 adaptor.addChild(root_0, root_1);
 1226  
                 }
 1227  
 
 1228  
             }
 1229  46
 
 1230  
 
 1231  184
             retval.tree = root_0;
 1232  46
 
 1233  46
             }
 1234  
 
 1235  184
             retval.stop = input.LT(-1);
 1236  
 
 1237  
 
 1238  184
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1239  184
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1240  
 
 1241  
         }
 1242  0
         catch (RecognitionException re) {
 1243  0
             reportError(re);
 1244  0
             recover(input,re);
 1245  46
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1246  46
 
 1247  
         }
 1248  
 
 1249  0
         finally {
 1250  
                 // do for sure before leaving
 1251  184
         }
 1252  184
         return retval;
 1253  1660
     }
 1254  
     // $ANTLR end "subSelect"
 1255  
 
 1256  
 
 1257  6460
     public static class selectClause_return extends ParserRuleReturnScope {
 1258  
         Object tree;
 1259  6460
         public Object getTree() { return tree; }
 1260  1660
     };
 1261  1660
 
 1262  
 
 1263  
     // $ANTLR start "selectClause"
 1264  1660
     // com\\googlecode\\sparkleg\\Sparql.g:124:1: selectClause : ( SELECT ( DISTINCT | REDUCED )? '*' -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) );
 1265  
     public final SparqlParser.selectClause_return selectClause() throws RecognitionException {
 1266  8120
         SparqlParser.selectClause_return retval = new SparqlParser.selectClause_return();
 1267  8120
         retval.start = input.LT(1);
 1268  1660
 
 1269  1660
 
 1270  8120
         Object root_0 = null;
 1271  1660
 
 1272  8120
         Token SELECT26=null;
 1273  8120
         Token DISTINCT27=null;
 1274  8120
         Token REDUCED28=null;
 1275  8120
         Token char_literal29=null;
 1276  8120
         Token SELECT30=null;
 1277  8120
         Token DISTINCT31=null;
 1278  8120
         Token REDUCED32=null;
 1279  8120
         List list_v=null;
 1280  8120
         RuleReturnScope v = null;
 1281  8120
         Object SELECT26_tree=null;
 1282  8120
         Object DISTINCT27_tree=null;
 1283  8120
         Object REDUCED28_tree=null;
 1284  8120
         Object char_literal29_tree=null;
 1285  8120
         Object SELECT30_tree=null;
 1286  8120
         Object DISTINCT31_tree=null;
 1287  6460
         Object REDUCED32_tree=null;
 1288  6460
         RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
 1289  8120
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 1290  8120
         RewriteRuleTokenStream stream_REDUCED=new RewriteRuleTokenStream(adaptor,"token REDUCED");
 1291  6460
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 1292  6460
         RewriteRuleSubtreeStream stream_selectVariables=new RewriteRuleSubtreeStream(adaptor,"rule selectVariables");
 1293  1660
         try {
 1294  
             // com\\googlecode\\sparkleg\\Sparql.g:125:5: ( SELECT ( DISTINCT | REDUCED )? '*' -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) )
 1295  6460
             int alt10=2;
 1296  6504
             switch ( input.LA(1) ) {
 1297  
             case SELECT:
 1298  
                 {
 1299  6462
                 switch ( input.LA(2) ) {
 1300  
                 case DISTINCT:
 1301  2
                     {
 1302  176
                     switch ( input.LA(3) ) {
 1303  
                     case ASTERISK:
 1304  
                         {
 1305  8
                         alt10=1;
 1306  42
                         }
 1307  8
                         break;
 1308  42
                     case VAR1:
 1309  
                     case VAR2:
 1310  
                     case 209:
 1311  
                         {
 1312  168
                         alt10=2;
 1313  
                         }
 1314  168
                         break;
 1315  
                     default:
 1316  0
                         NoViableAltException nvae =
 1317  
                             new NoViableAltException("", 10, 2, input);
 1318  44
 
 1319  0
                         throw nvae;
 1320  
 
 1321  14
                     }
 1322  
 
 1323  
                     }
 1324  180
                     break;
 1325  
                 case REDUCED:
 1326  4
                     {
 1327  56
                     switch ( input.LA(3) ) {
 1328  
                     case ASTERISK:
 1329  
                         {
 1330  16
                         alt10=1;
 1331  10
                         }
 1332  16
                         break;
 1333  10
                     case VAR1:
 1334  
                     case VAR2:
 1335  
                     case 209:
 1336  
                         {
 1337  40
                         alt10=2;
 1338  
                         }
 1339  40
                         break;
 1340  
                     default:
 1341  0
                         NoViableAltException nvae =
 1342  
                             new NoViableAltException("", 10, 3, input);
 1343  14
 
 1344  0
                         throw nvae;
 1345  
 
 1346  680
                     }
 1347  
 
 1348  680
                     }
 1349  56
                     break;
 1350  
                 case ASTERISK:
 1351  
                     {
 1352  2516
                     alt10=1;
 1353  922
                     }
 1354  2516
                     break;
 1355  922
                 case VAR1:
 1356  
                 case VAR2:
 1357  
                 case 209:
 1358  
                     {
 1359  3712
                     alt10=2;
 1360  
                     }
 1361  3712
                     break;
 1362  
                 default:
 1363  0
                     NoViableAltException nvae =
 1364  
                         new NoViableAltException("", 10, 1, input);
 1365  1660
 
 1366  0
                     throw nvae;
 1367  
 
 1368  
                 }
 1369  
 
 1370  
                 }
 1371  6460
                 break;
 1372  
             default:
 1373  0
                 NoViableAltException nvae =
 1374  1660
                     new NoViableAltException("", 10, 0, input);
 1375  
 
 1376  0
                 throw nvae;
 1377  
 
 1378  686
             }
 1379  686
 
 1380  6460
             switch (alt10) {
 1381  
                 case 1 :
 1382  
                     // com\\googlecode\\sparkleg\\Sparql.g:125:7: SELECT ( DISTINCT | REDUCED )? '*'
 1383  686
                     {
 1384  3226
                     SELECT26=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause520);  
 1385  2540
                     stream_SELECT.add(SELECT26);
 1386  
 
 1387  2
 
 1388  
                     // com\\googlecode\\sparkleg\\Sparql.g:125:14: ( DISTINCT | REDUCED )?
 1389  2542
                     int alt7=3;
 1390  2540
                     switch ( input.LA(1) ) {
 1391  
                         case DISTINCT:
 1392  4
                             {
 1393  8
                             alt7=1;
 1394  
                             }
 1395  8
                             break;
 1396  
                         case REDUCED:
 1397  686
                             {
 1398  16
                             alt7=2;
 1399  
                             }
 1400  
                             break;
 1401  2
                     }
 1402  2
 
 1403  2540
                     switch (alt7) {
 1404  
                         case 1 :
 1405  
                             // com\\googlecode\\sparkleg\\Sparql.g:125:15: DISTINCT
 1406  2
                             {
 1407  8
                             DISTINCT27=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause523);  
 1408  8
                             stream_DISTINCT.add(DISTINCT27);
 1409  
 
 1410  4
 
 1411  4
                             }
 1412  8
                             break;
 1413  
                         case 2 :
 1414  
                             // com\\googlecode\\sparkleg\\Sparql.g:125:26: REDUCED
 1415  
                             {
 1416  16
                             REDUCED28=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause527);  
 1417  16
                             stream_REDUCED.add(REDUCED28);
 1418  
 
 1419  
 
 1420  686
                             }
 1421  686
                             break;
 1422  
 
 1423  
                     }
 1424  
 
 1425  
 
 1426  2540
                     char_literal29=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause531);  
 1427  2540
                     stream_ASTERISK.add(char_literal29);
 1428  
 
 1429  
 
 1430  
                     // AST REWRITE
 1431  686
                     // elements: DISTINCT, REDUCED, ASTERISK
 1432  686
                     // token labels: 
 1433  
                     // rule labels: retval
 1434  686
                     // token list labels: 
 1435  
                     // rule list labels: 
 1436  
                     // wildcard labels: 
 1437  2540
                     retval.tree = root_0;
 1438  2540
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1439  686
 
 1440  3226
                     root_0 = (Object)adaptor.nil();
 1441  
                     // 125:40: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' )
 1442  
                     {
 1443  
                         // com\\googlecode\\sparkleg\\Sparql.g:125:43: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* '*' )
 1444  
                         {
 1445  3228
                         Object root_1 = (Object)adaptor.nil();
 1446  2542
                         root_1 = (Object)adaptor.becomeRoot(
 1447  
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1448  
                         , root_1);
 1449  
 
 1450  
                         // com\\googlecode\\sparkleg\\Sparql.g:125:59: ( DISTINCT )*
 1451  3234
                         while ( stream_DISTINCT.hasNext() ) {
 1452  8
                             adaptor.addChild(root_1, 
 1453  
                             stream_DISTINCT.nextNode()
 1454  690
                             );
 1455  4
 
 1456  
                         }
 1457  2540
                         stream_DISTINCT.reset();
 1458  
 
 1459  
                         // com\\googlecode\\sparkleg\\Sparql.g:125:69: ( REDUCED )*
 1460  3242
                         while ( stream_REDUCED.hasNext() ) {
 1461  16
                             adaptor.addChild(root_1, 
 1462  686
                             stream_REDUCED.nextNode()
 1463  
                             );
 1464  
 
 1465  
                         }
 1466  3226
                         stream_REDUCED.reset();
 1467  
 
 1468  2540
                         adaptor.addChild(root_1, 
 1469  
                         stream_ASTERISK.nextNode()
 1470  
                         );
 1471  
 
 1472  3226
                         adaptor.addChild(root_0, root_1);
 1473  
                         }
 1474  
 
 1475  686
                     }
 1476  
 
 1477  
 
 1478  2540
                     retval.tree = root_0;
 1479  974
 
 1480  974
                     }
 1481  2540
                     break;
 1482  
                 case 2 :
 1483  
                     // com\\googlecode\\sparkleg\\Sparql.g:126:7: SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+
 1484  974
                     {
 1485  4894
                     SELECT30=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause553);  
 1486  3920
                     stream_SELECT.add(SELECT30);
 1487  
 
 1488  42
 
 1489  
                     // com\\googlecode\\sparkleg\\Sparql.g:126:14: ( DISTINCT | REDUCED )?
 1490  3962
                     int alt8=3;
 1491  3920
                     switch ( input.LA(1) ) {
 1492  
                         case DISTINCT:
 1493  10
                             {
 1494  168
                             alt8=1;
 1495  
                             }
 1496  168
                             break;
 1497  
                         case REDUCED:
 1498  974
                             {
 1499  40
                             alt8=2;
 1500  
                             }
 1501  
                             break;
 1502  42
                     }
 1503  42
 
 1504  3920
                     switch (alt8) {
 1505  
                         case 1 :
 1506  
                             // com\\googlecode\\sparkleg\\Sparql.g:126:15: DISTINCT
 1507  42
                             {
 1508  168
                             DISTINCT31=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause556);  
 1509  168
                             stream_DISTINCT.add(DISTINCT31);
 1510  
 
 1511  10
 
 1512  10
                             }
 1513  168
                             break;
 1514  
                         case 2 :
 1515  
                             // com\\googlecode\\sparkleg\\Sparql.g:126:26: REDUCED
 1516  
                             {
 1517  40
                             REDUCED32=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause560);  
 1518  40
                             stream_REDUCED.add(REDUCED32);
 1519  
 
 1520  
 
 1521  
                             }
 1522  974
                             break;
 1523  
 
 1524  
                     }
 1525  2630
 
 1526  2630
 
 1527  
                     // com\\googlecode\\sparkleg\\Sparql.g:126:36: (v+= selectVariables )+
 1528  3920
                     int cnt9=0;
 1529  
                     loop9:
 1530  
                     do {
 1531  12230
                         int alt9=2;
 1532  10574
                         switch ( input.LA(1) ) {
 1533  
                         case VAR1:
 1534  
                         case VAR2:
 1535  
                         case 209:
 1536  
                             {
 1537  9284
                             alt9=1;
 1538  
                             }
 1539  
                             break;
 1540  
 
 1541  1656
                         }
 1542  1656
 
 1543  10574
                         switch (alt9) {
 1544  1656
                             case 1 :
 1545  
                                 // com\\googlecode\\sparkleg\\Sparql.g:126:37: v+= selectVariables
 1546  1656
                                 {
 1547  8310
                                 pushFollow(FOLLOW_selectVariables_in_selectClause567);
 1548  8310
                                 v=selectVariables();
 1549  
 
 1550  6654
                                 state._fsp--;
 1551  
 
 1552  8310
                                 stream_selectVariables.add(v.getTree());
 1553  6654
                                 if (list_v==null) list_v=new ArrayList();
 1554  6654
                                 list_v.add(v.getTree());
 1555  974
 
 1556  
 
 1557  
                                 }
 1558  6654
                                 break;
 1559  
 
 1560  1656
                             default :
 1561  5576
                                 if ( cnt9 >= 1 ) break loop9;
 1562  0
                                 EarlyExitException eee =
 1563  
                                     new EarlyExitException(9, input);
 1564  0
                                 throw eee;
 1565  
                         }
 1566  6654
                         cnt9++;
 1567  6654
                     } while (true);
 1568  
 
 1569  
 
 1570  
                     // AST REWRITE
 1571  974
                     // elements: DISTINCT, v, REDUCED
 1572  974
                     // token labels: 
 1573  974
                     // rule labels: retval
 1574  974
                     // token list labels: 
 1575  
                     // rule list labels: v
 1576  
                     // wildcard labels: 
 1577  3920
                     retval.tree = root_0;
 1578  3920
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1579  4894
                     RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 1580  4894
                     root_0 = (Object)adaptor.nil();
 1581  
                     // 126:58: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1582  
                     {
 1583  
                         // com\\googlecode\\sparkleg\\Sparql.g:126:61: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1584  
                         {
 1585  4936
                         Object root_1 = (Object)adaptor.nil();
 1586  3962
                         root_1 = (Object)adaptor.becomeRoot(
 1587  
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1588  
                         , root_1);
 1589  
 
 1590  
                         // com\\googlecode\\sparkleg\\Sparql.g:126:77: ( DISTINCT )*
 1591  5062
                         while ( stream_DISTINCT.hasNext() ) {
 1592  168
                             adaptor.addChild(root_1, 
 1593  
                             stream_DISTINCT.nextNode()
 1594  984
                             );
 1595  10
 
 1596  
                         }
 1597  3920
                         stream_DISTINCT.reset();
 1598  
 
 1599  
                         // com\\googlecode\\sparkleg\\Sparql.g:126:87: ( REDUCED )*
 1600  4934
                         while ( stream_REDUCED.hasNext() ) {
 1601  40
                             adaptor.addChild(root_1, 
 1602  
                             stream_REDUCED.nextNode()
 1603  2630
                             );
 1604  1656
 
 1605  
                         }
 1606  3920
                         stream_REDUCED.reset();
 1607  974
 
 1608  
                         // com\\googlecode\\sparkleg\\Sparql.g:126:97: ( $v)*
 1609  11548
                         while ( stream_v.hasNext() ) {
 1610  6654
                             adaptor.addChild(root_1, stream_v.nextTree());
 1611  
 
 1612  
                         }
 1613  3920
                         stream_v.reset();
 1614  
 
 1615  4894
                         adaptor.addChild(root_0, root_1);
 1616  
                         }
 1617  
 
 1618  
                     }
 1619  
 
 1620  
 
 1621  5580
                     retval.tree = root_0;
 1622  
 
 1623  
                     }
 1624  1660
                     break;
 1625  1660
 
 1626  
             }
 1627  6460
             retval.stop = input.LT(-1);
 1628  
 
 1629  
 
 1630  6460
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1631  6460
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1632  
 
 1633  
         }
 1634  0
         catch (RecognitionException re) {
 1635  0
             reportError(re);
 1636  0
             recover(input,re);
 1637  1660
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1638  1660
 
 1639  
         }
 1640  
 
 1641  0
         finally {
 1642  
                 // do for sure before leaving
 1643  6460
         }
 1644  6460
         return retval;
 1645  3312
     }
 1646  
     // $ANTLR end "selectClause"
 1647  
 
 1648  
 
 1649  6654
     public static class selectVariables_return extends ParserRuleReturnScope {
 1650  
         Object tree;
 1651  13308
         public Object getTree() { return tree; }
 1652  1656
     };
 1653  1656
 
 1654  
 
 1655  
     // $ANTLR start "selectVariables"
 1656  1656
     // com\\googlecode\\sparkleg\\Sparql.g:129:1: selectVariables : ( var -> ^( VAR var ) | '(' expression AS var ')' -> ^( AS expression var ) );
 1657  
     public final SparqlParser.selectVariables_return selectVariables() throws RecognitionException {
 1658  8310
         SparqlParser.selectVariables_return retval = new SparqlParser.selectVariables_return();
 1659  8310
         retval.start = input.LT(1);
 1660  1656
 
 1661  1656
 
 1662  6654
         Object root_0 = null;
 1663  1656
 
 1664  6654
         Token char_literal34=null;
 1665  8310
         Token AS36=null;
 1666  6654
         Token char_literal38=null;
 1667  6654
         SparqlParser.var_return var33 =null;
 1668  1656
 
 1669  8310
         SparqlParser.expression_return expression35 =null;
 1670  1656
 
 1671  8310
         SparqlParser.var_return var37 =null;
 1672  1656
 
 1673  1656
 
 1674  8310
         Object char_literal34_tree=null;
 1675  8310
         Object AS36_tree=null;
 1676  6654
         Object char_literal38_tree=null;
 1677  6654
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 1678  8310
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 1679  8310
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 1680  6654
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1681  6654
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 1682  
         try {
 1683  1406
             // com\\googlecode\\sparkleg\\Sparql.g:130:5: ( var -> ^( VAR var ) | '(' expression AS var ')' -> ^( AS expression var ) )
 1684  6654
             int alt11=2;
 1685  8060
             switch ( input.LA(1) ) {
 1686  
             case VAR1:
 1687  
             case VAR2:
 1688  250
                 {
 1689  5654
                 alt11=1;
 1690  250
                 }
 1691  5654
                 break;
 1692  
             case 209:
 1693  
                 {
 1694  1000
                 alt11=2;
 1695  
                 }
 1696  1000
                 break;
 1697  
             default:
 1698  0
                 NoViableAltException nvae =
 1699  1656
                     new NoViableAltException("", 11, 0, input);
 1700  
 
 1701  0
                 throw nvae;
 1702  
 
 1703  1406
             }
 1704  1406
 
 1705  6654
             switch (alt11) {
 1706  1406
                 case 1 :
 1707  
                     // com\\googlecode\\sparkleg\\Sparql.g:130:7: var
 1708  1406
                     {
 1709  5654
                     pushFollow(FOLLOW_var_in_selectVariables602);
 1710  5654
                     var33=var();
 1711  
 
 1712  5654
                     state._fsp--;
 1713  
 
 1714  5654
                     stream_var.add(var33.getTree());
 1715  
 
 1716  
                     // AST REWRITE
 1717  1406
                     // elements: var
 1718  1406
                     // token labels: 
 1719  
                     // rule labels: retval
 1720  1406
                     // token list labels: 
 1721  
                     // rule list labels: 
 1722  
                     // wildcard labels: 
 1723  5654
                     retval.tree = root_0;
 1724  5654
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1725  1406
 
 1726  7060
                     root_0 = (Object)adaptor.nil();
 1727  
                     // 130:11: -> ^( VAR var )
 1728  
                     {
 1729  
                         // com\\googlecode\\sparkleg\\Sparql.g:130:14: ^( VAR var )
 1730  1406
                         {
 1731  5654
                         Object root_1 = (Object)adaptor.nil();
 1732  7060
                         root_1 = (Object)adaptor.becomeRoot(
 1733  
                         (Object)adaptor.create(VAR, "VAR")
 1734  
                         , root_1);
 1735  
 
 1736  5654
                         adaptor.addChild(root_1, stream_var.nextTree());
 1737  
 
 1738  7060
                         adaptor.addChild(root_0, root_1);
 1739  
                         }
 1740  
 
 1741  1406
                     }
 1742  
 
 1743  
 
 1744  5654
                     retval.tree = root_0;
 1745  250
 
 1746  250
                     }
 1747  5654
                     break;
 1748  
                 case 2 :
 1749  250
                     // com\\googlecode\\sparkleg\\Sparql.g:131:7: '(' expression AS var ')'
 1750  250
                     {
 1751  1000
                     char_literal34=(Token)match(input,209,FOLLOW_209_in_selectVariables619);  
 1752  1250
                     stream_209.add(char_literal34);
 1753  
 
 1754  250
 
 1755  1000
                     pushFollow(FOLLOW_expression_in_selectVariables621);
 1756  1250
                     expression35=expression();
 1757  250
 
 1758  1000
                     state._fsp--;
 1759  
 
 1760  1250
                     stream_expression.add(expression35.getTree());
 1761  250
 
 1762  1000
                     AS36=(Token)match(input,AS,FOLLOW_AS_in_selectVariables623);  
 1763  1250
                     stream_AS.add(AS36);
 1764  
 
 1765  250
 
 1766  1000
                     pushFollow(FOLLOW_var_in_selectVariables625);
 1767  1250
                     var37=var();
 1768  250
 
 1769  1000
                     state._fsp--;
 1770  
 
 1771  1000
                     stream_var.add(var37.getTree());
 1772  
 
 1773  1000
                     char_literal38=(Token)match(input,210,FOLLOW_210_in_selectVariables627);  
 1774  1000
                     stream_210.add(char_literal38);
 1775  
 
 1776  
 
 1777  
                     // AST REWRITE
 1778  250
                     // elements: expression, AS, var
 1779  250
                     // token labels: 
 1780  
                     // rule labels: retval
 1781  250
                     // token list labels: 
 1782  
                     // rule list labels: 
 1783  
                     // wildcard labels: 
 1784  1000
                     retval.tree = root_0;
 1785  1000
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1786  250
 
 1787  1250
                     root_0 = (Object)adaptor.nil();
 1788  
                     // 131:33: -> ^( AS expression var )
 1789  
                     {
 1790  
                         // com\\googlecode\\sparkleg\\Sparql.g:131:36: ^( AS expression var )
 1791  250
                         {
 1792  1000
                         Object root_1 = (Object)adaptor.nil();
 1793  1250
                         root_1 = (Object)adaptor.becomeRoot(
 1794  
                         stream_AS.nextNode()
 1795  250
                         , root_1);
 1796  
 
 1797  1000
                         adaptor.addChild(root_1, stream_expression.nextTree());
 1798  
 
 1799  1000
                         adaptor.addChild(root_1, stream_var.nextTree());
 1800  
 
 1801  1250
                         adaptor.addChild(root_0, root_1);
 1802  
                         }
 1803  
 
 1804  
                     }
 1805  
 
 1806  
 
 1807  2656
                     retval.tree = root_0;
 1808  
 
 1809  
                     }
 1810  1656
                     break;
 1811  1656
 
 1812  
             }
 1813  6654
             retval.stop = input.LT(-1);
 1814  
 
 1815  
 
 1816  6654
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1817  6654
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1818  
 
 1819  
         }
 1820  0
         catch (RecognitionException re) {
 1821  0
             reportError(re);
 1822  0
             recover(input,re);
 1823  1656
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1824  1656
 
 1825  
         }
 1826  
 
 1827  0
         finally {
 1828  
                 // do for sure before leaving
 1829  6654
         }
 1830  6654
         return retval;
 1831  72
     }
 1832  
     // $ANTLR end "selectVariables"
 1833  
 
 1834  
 
 1835  270
     public static class constructQuery_return extends ParserRuleReturnScope {
 1836  
         Object tree;
 1837  270
         public Object getTree() { return tree; }
 1838  72
     };
 1839  72
 
 1840  
 
 1841  
     // $ANTLR start "constructQuery"
 1842  72
     // com\\googlecode\\sparkleg\\Sparql.g:134:1: constructQuery : ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE '{' ( triplesTemplate )? '}' solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* ) );
 1843  
     public final SparqlParser.constructQuery_return constructQuery() throws RecognitionException {
 1844  342
         SparqlParser.constructQuery_return retval = new SparqlParser.constructQuery_return();
 1845  342
         retval.start = input.LT(1);
 1846  72
 
 1847  72
 
 1848  342
         Object root_0 = null;
 1849  72
 
 1850  270
         Token CONSTRUCT39=null;
 1851  342
         Token CONSTRUCT44=null;
 1852  270
         Token WHERE46=null;
 1853  342
         Token char_literal47=null;
 1854  270
         Token char_literal49=null;
 1855  342
         SparqlParser.constructTemplate_return constructTemplate40 =null;
 1856  
 
 1857  342
         SparqlParser.datasetClause_return datasetClause41 =null;
 1858  
 
 1859  342
         SparqlParser.whereClause_return whereClause42 =null;
 1860  
 
 1861  342
         SparqlParser.solutionModifier_return solutionModifier43 =null;
 1862  
 
 1863  270
         SparqlParser.datasetClause_return datasetClause45 =null;
 1864  72
 
 1865  342
         SparqlParser.triplesTemplate_return triplesTemplate48 =null;
 1866  72
 
 1867  342
         SparqlParser.solutionModifier_return solutionModifier50 =null;
 1868  72
 
 1869  72
 
 1870  342
         Object CONSTRUCT39_tree=null;
 1871  342
         Object CONSTRUCT44_tree=null;
 1872  342
         Object WHERE46_tree=null;
 1873  342
         Object char_literal47_tree=null;
 1874  342
         Object char_literal49_tree=null;
 1875  342
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 1876  342
         RewriteRuleTokenStream stream_CONSTRUCT=new RewriteRuleTokenStream(adaptor,"token CONSTRUCT");
 1877  342
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 1878  270
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 1879  270
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1880  342
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 1881  342
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1882  270
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1883  270
         RewriteRuleSubtreeStream stream_constructTemplate=new RewriteRuleSubtreeStream(adaptor,"rule constructTemplate");
 1884  72
         try {
 1885  
             // com\\googlecode\\sparkleg\\Sparql.g:135:5: ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE '{' ( triplesTemplate )? '}' solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* ) )
 1886  270
             int alt15=2;
 1887  324
             switch ( input.LA(1) ) {
 1888  
             case CONSTRUCT:
 1889  54
                 {
 1890  270
                 switch ( input.LA(2) ) {
 1891  
                 case 216:
 1892  
                     {
 1893  232
                     alt15=1;
 1894  
                     }
 1895  232
                     break;
 1896  
                 case FROM:
 1897  2
                 case WHERE:
 1898  
                     {
 1899  52
                     alt15=2;
 1900  2
                     }
 1901  52
                     break;
 1902  
                 default:
 1903  2
                     NoViableAltException nvae =
 1904  
                         new NoViableAltException("", 15, 1, input);
 1905  70
 
 1906  2
                     throw nvae;
 1907  
 
 1908  
                 }
 1909  
 
 1910  
                 }
 1911  268
                 break;
 1912  
             default:
 1913  0
                 NoViableAltException nvae =
 1914  70
                     new NoViableAltException("", 15, 0, input);
 1915  
 
 1916  0
                 throw nvae;
 1917  
 
 1918  54
             }
 1919  54
 
 1920  268
             switch (alt15) {
 1921  
                 case 1 :
 1922  54
                     // com\\googlecode\\sparkleg\\Sparql.g:135:7: CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier
 1923  54
                     {
 1924  216
                     CONSTRUCT39=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery654);  
 1925  270
                     stream_CONSTRUCT.add(CONSTRUCT39);
 1926  
 
 1927  54
 
 1928  216
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery656);
 1929  216
                     constructTemplate40=constructTemplate();
 1930  
 
 1931  216
                     state._fsp--;
 1932  54
 
 1933  270
                     stream_constructTemplate.add(constructTemplate40.getTree());
 1934  
 
 1935  
                     // com\\googlecode\\sparkleg\\Sparql.g:135:35: ( datasetClause )*
 1936  
                     loop12:
 1937  
                     do {
 1938  216
                         int alt12=2;
 1939  216
                         switch ( input.LA(1) ) {
 1940  
                         case FROM:
 1941  
                             {
 1942  54
                             alt12=1;
 1943  
                             }
 1944  
                             break;
 1945  
 
 1946  
                         }
 1947  
 
 1948  216
                         switch (alt12) {
 1949  
                             case 1 :
 1950  
                                 // com\\googlecode\\sparkleg\\Sparql.g:135:35: datasetClause
 1951  
                                 {
 1952  0
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery658);
 1953  0
                                 datasetClause41=datasetClause();
 1954  
 
 1955  0
                                 state._fsp--;
 1956  
 
 1957  54
                                 stream_datasetClause.add(datasetClause41.getTree());
 1958  
 
 1959  
                                 }
 1960  0
                                 break;
 1961  
 
 1962  54
                             default :
 1963  270
                                 break loop12;
 1964  
                         }
 1965  54
                     } while (true);
 1966  
 
 1967  54
 
 1968  216
                     pushFollow(FOLLOW_whereClause_in_constructQuery661);
 1969  270
                     whereClause42=whereClause();
 1970  54
 
 1971  216
                     state._fsp--;
 1972  54
 
 1973  216
                     stream_whereClause.add(whereClause42.getTree());
 1974  54
 
 1975  216
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery663);
 1976  216
                     solutionModifier43=solutionModifier();
 1977  
 
 1978  216
                     state._fsp--;
 1979  
 
 1980  216
                     stream_solutionModifier.add(solutionModifier43.getTree());
 1981  
 
 1982  
                     // AST REWRITE
 1983  54
                     // elements: whereClause, constructTemplate, CONSTRUCT, solutionModifier, datasetClause
 1984  54
                     // token labels: 
 1985  
                     // rule labels: retval
 1986  54
                     // token list labels: 
 1987  
                     // rule list labels: 
 1988  
                     // wildcard labels: 
 1989  216
                     retval.tree = root_0;
 1990  216
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1991  54
 
 1992  270
                     root_0 = (Object)adaptor.nil();
 1993  
                     // 135:79: -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1994  
                     {
 1995  
                         // com\\googlecode\\sparkleg\\Sparql.g:135:82: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1996  54
                         {
 1997  216
                         Object root_1 = (Object)adaptor.nil();
 1998  216
                         root_1 = (Object)adaptor.becomeRoot(
 1999  54
                         stream_CONSTRUCT.nextNode()
 2000  
                         , root_1);
 2001  
 
 2002  216
                         adaptor.addChild(root_1, stream_constructTemplate.nextTree());
 2003  54
 
 2004  
                         // com\\googlecode\\sparkleg\\Sparql.g:135:112: ( datasetClause )*
 2005  216
                         while ( stream_datasetClause.hasNext() ) {
 2006  108
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2007  54
 
 2008  
                         }
 2009  216
                         stream_datasetClause.reset();
 2010  54
 
 2011  
                         // com\\googlecode\\sparkleg\\Sparql.g:135:127: ( whereClause )*
 2012  432
                         while ( stream_whereClause.hasNext() ) {
 2013  276
                             adaptor.addChild(root_1, stream_whereClause.nextTree());
 2014  6
 
 2015  
                         }
 2016  216
                         stream_whereClause.reset();
 2017  54
 
 2018  
                         // com\\googlecode\\sparkleg\\Sparql.g:135:140: ( solutionModifier )*
 2019  294
                         while ( stream_solutionModifier.hasNext() ) {
 2020  24
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2021  
 
 2022  
                         }
 2023  216
                         stream_solutionModifier.reset();
 2024  
 
 2025  270
                         adaptor.addChild(root_0, root_1);
 2026  
                         }
 2027  
 
 2028  54
                     }
 2029  
 
 2030  
 
 2031  216
                     retval.tree = root_0;
 2032  16
 
 2033  16
                     }
 2034  216
                     break;
 2035  
                 case 2 :
 2036  
                     // com\\googlecode\\sparkleg\\Sparql.g:136:7: CONSTRUCT ( datasetClause )* WHERE '{' ( triplesTemplate )? '}' solutionModifier
 2037  
                     {
 2038  52
                     CONSTRUCT44=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery691);  
 2039  70
                     stream_CONSTRUCT.add(CONSTRUCT44);
 2040  18
 
 2041  
 
 2042  
                     // com\\googlecode\\sparkleg\\Sparql.g:136:17: ( datasetClause )*
 2043  2
                     loop13:
 2044  
                     do {
 2045  60
                         int alt13=2;
 2046  60
                         switch ( input.LA(1) ) {
 2047  
                         case FROM:
 2048  
                             {
 2049  26
                             alt13=1;
 2050  
                             }
 2051  
                             break;
 2052  
 
 2053  2
                         }
 2054  2
 
 2055  60
                         switch (alt13) {
 2056  2
                             case 1 :
 2057  
                                 // com\\googlecode\\sparkleg\\Sparql.g:136:17: datasetClause
 2058  2
                                 {
 2059  8
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery693);
 2060  8
                                 datasetClause45=datasetClause();
 2061  2
 
 2062  8
                                 state._fsp--;
 2063  
 
 2064  24
                                 stream_datasetClause.add(datasetClause45.getTree());
 2065  
 
 2066  2
                                 }
 2067  8
                                 break;
 2068  
 
 2069  16
                             default :
 2070  68
                                 break loop13;
 2071  
                         }
 2072  8
                     } while (true);
 2073  16
 
 2074  16
 
 2075  52
                     WHERE46=(Token)match(input,WHERE,FOLLOW_WHERE_in_constructQuery696);  
 2076  52
                     stream_WHERE.add(WHERE46);
 2077  
 
 2078  16
 
 2079  68
                     char_literal47=(Token)match(input,216,FOLLOW_216_in_constructQuery698);  
 2080  52
                     stream_216.add(char_literal47);
 2081  
 
 2082  
 
 2083  
                     // com\\googlecode\\sparkleg\\Sparql.g:136:42: ( triplesTemplate )?
 2084  52
                     int alt14=2;
 2085  52
                     switch ( input.LA(1) ) {
 2086  
                         case BLANK_NODE_LABEL:
 2087  
                         case DECIMAL:
 2088  
                         case DECIMAL_NEGATIVE:
 2089  
                         case DECIMAL_POSITIVE:
 2090  
                         case DOUBLE:
 2091  
                         case DOUBLE_NEGATIVE:
 2092  
                         case DOUBLE_POSITIVE:
 2093  
                         case FALSE:
 2094  
                         case INTEGER:
 2095  
                         case INTEGER_NEGATIVE:
 2096  
                         case INTEGER_POSITIVE:
 2097  
                         case IRI_REF:
 2098  
                         case PNAME_LN:
 2099  
                         case PNAME_NS:
 2100  
                         case STRING_LITERAL1:
 2101  
                         case STRING_LITERAL2:
 2102  
                         case STRING_LITERAL_LONG1:
 2103  
                         case STRING_LITERAL_LONG2:
 2104  14
                         case TRUE:
 2105  
                         case VAR1:
 2106  
                         case VAR2:
 2107  
                         case 209:
 2108  
                         case 213:
 2109  16
                             {
 2110  50
                             alt14=1;
 2111  
                             }
 2112  
                             break;
 2113  14
                     }
 2114  14
 
 2115  52
                     switch (alt14) {
 2116  14
                         case 1 :
 2117  
                             // com\\googlecode\\sparkleg\\Sparql.g:136:42: triplesTemplate
 2118  14
                             {
 2119  50
                             pushFollow(FOLLOW_triplesTemplate_in_constructQuery700);
 2120  50
                             triplesTemplate48=triplesTemplate();
 2121  
 
 2122  50
                             state._fsp--;
 2123  
 
 2124  50
                             stream_triplesTemplate.add(triplesTemplate48.getTree());
 2125  
 
 2126  16
                             }
 2127  12
                             break;
 2128  
 
 2129  
                     }
 2130  12
 
 2131  12
 
 2132  52
                     char_literal49=(Token)match(input,218,FOLLOW_218_in_constructQuery703);  
 2133  60
                     stream_218.add(char_literal49);
 2134  
 
 2135  12
 
 2136  48
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery705);
 2137  48
                     solutionModifier50=solutionModifier();
 2138  
 
 2139  48
                     state._fsp--;
 2140  
 
 2141  48
                     stream_solutionModifier.add(solutionModifier50.getTree());
 2142  
 
 2143  
                     // AST REWRITE
 2144  12
                     // elements: solutionModifier, CONSTRUCT, triplesTemplate, datasetClause
 2145  12
                     // token labels: 
 2146  
                     // rule labels: retval
 2147  12
                     // token list labels: 
 2148  
                     // rule list labels: 
 2149  
                     // wildcard labels: 
 2150  48
                     retval.tree = root_0;
 2151  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2152  12
 
 2153  60
                     root_0 = (Object)adaptor.nil();
 2154  
                     // 136:80: -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* )
 2155  
                     {
 2156  
                         // com\\googlecode\\sparkleg\\Sparql.g:136:83: ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( triplesTemplate )* ) ( solutionModifier )* )
 2157  
                         {
 2158  62
                         Object root_1 = (Object)adaptor.nil();
 2159  50
                         root_1 = (Object)adaptor.becomeRoot(
 2160  
                         stream_CONSTRUCT.nextNode()
 2161  
                         , root_1);
 2162  12
 
 2163  
                         // com\\googlecode\\sparkleg\\Sparql.g:136:95: ( datasetClause )*
 2164  56
                         while ( stream_datasetClause.hasNext() ) {
 2165  8
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2166  12
 
 2167  12
                         }
 2168  48
                         stream_datasetClause.reset();
 2169  
 
 2170  
                         // com\\googlecode\\sparkleg\\Sparql.g:136:110: ^( WHERE_CLAUSE ( triplesTemplate )* )
 2171  
                         {
 2172  72
                         Object root_2 = (Object)adaptor.nil();
 2173  60
                         root_2 = (Object)adaptor.becomeRoot(
 2174  
                         (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2175  
                         , root_2);
 2176  12
 
 2177  
                         // com\\googlecode\\sparkleg\\Sparql.g:136:125: ( triplesTemplate )*
 2178  108
                         while ( stream_triplesTemplate.hasNext() ) {
 2179  48
                             adaptor.addChild(root_2, stream_triplesTemplate.nextTree());
 2180  
 
 2181  
                         }
 2182  60
                         stream_triplesTemplate.reset();
 2183  
 
 2184  48
                         adaptor.addChild(root_1, root_2);
 2185  
                         }
 2186  12
 
 2187  
                         // com\\googlecode\\sparkleg\\Sparql.g:136:143: ( solutionModifier )*
 2188  60
                         while ( stream_solutionModifier.hasNext() ) {
 2189  0
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2190  
 
 2191  
                         }
 2192  48
                         stream_solutionModifier.reset();
 2193  
 
 2194  60
                         adaptor.addChild(root_0, root_1);
 2195  
                         }
 2196  
 
 2197  
                     }
 2198  
 
 2199  
 
 2200  114
                     retval.tree = root_0;
 2201  
 
 2202  
                     }
 2203  66
                     break;
 2204  66
 
 2205  
             }
 2206  264
             retval.stop = input.LT(-1);
 2207  6
 
 2208  6
 
 2209  270
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2210  270
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2211  
 
 2212  
         }
 2213  6
         catch (RecognitionException re) {
 2214  6
             reportError(re);
 2215  6
             recover(input,re);
 2216  78
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2217  72
 
 2218  
         }
 2219  
 
 2220  0
         finally {
 2221  
                 // do for sure before leaving
 2222  270
         }
 2223  270
         return retval;
 2224  28
     }
 2225  
     // $ANTLR end "constructQuery"
 2226  
 
 2227  
 
 2228  112
     public static class describeQuery_return extends ParserRuleReturnScope {
 2229  
         Object tree;
 2230  112
         public Object getTree() { return tree; }
 2231  28
     };
 2232  28
 
 2233  
 
 2234  
     // $ANTLR start "describeQuery"
 2235  28
     // com\\googlecode\\sparkleg\\Sparql.g:139:1: describeQuery : DESCRIBE ( (v+= varOrIRIref )+ | '*' ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) ;
 2236  
     public final SparqlParser.describeQuery_return describeQuery() throws RecognitionException {
 2237  140
         SparqlParser.describeQuery_return retval = new SparqlParser.describeQuery_return();
 2238  140
         retval.start = input.LT(1);
 2239  28
 
 2240  28
 
 2241  112
         Object root_0 = null;
 2242  28
 
 2243  112
         Token DESCRIBE51=null;
 2244  140
         Token char_literal52=null;
 2245  112
         List list_v=null;
 2246  140
         SparqlParser.datasetClause_return datasetClause53 =null;
 2247  28
 
 2248  140
         SparqlParser.whereClause_return whereClause54 =null;
 2249  28
 
 2250  140
         SparqlParser.solutionModifier_return solutionModifier55 =null;
 2251  28
 
 2252  140
         RuleReturnScope v = null;
 2253  140
         Object DESCRIBE51_tree=null;
 2254  140
         Object char_literal52_tree=null;
 2255  112
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 2256  112
         RewriteRuleTokenStream stream_DESCRIBE=new RewriteRuleTokenStream(adaptor,"token DESCRIBE");
 2257  112
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 2258  112
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2259  140
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2260  140
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2261  
         try {
 2262  
             // com\\googlecode\\sparkleg\\Sparql.g:140:5: ( DESCRIBE ( (v+= varOrIRIref )+ | '*' ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) )
 2263  
             // com\\googlecode\\sparkleg\\Sparql.g:140:7: DESCRIBE ( (v+= varOrIRIref )+ | '*' ) ( datasetClause )* ( whereClause )? solutionModifier
 2264  28
             {
 2265  140
             DESCRIBE51=(Token)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery741);  
 2266  112
             stream_DESCRIBE.add(DESCRIBE51);
 2267  
 
 2268  
 
 2269  
             // com\\googlecode\\sparkleg\\Sparql.g:140:16: ( (v+= varOrIRIref )+ | '*' )
 2270  112
             int alt17=2;
 2271  112
             switch ( input.LA(1) ) {
 2272  28
             case IRI_REF:
 2273  
             case PNAME_LN:
 2274  28
             case PNAME_NS:
 2275  
             case VAR1:
 2276  
             case VAR2:
 2277  
                 {
 2278  112
                 alt17=1;
 2279  
                 }
 2280  112
                 break;
 2281  
             case ASTERISK:
 2282  
                 {
 2283  0
                 alt17=2;
 2284  
                 }
 2285  0
                 break;
 2286  
             default:
 2287  0
                 NoViableAltException nvae =
 2288  28
                     new NoViableAltException("", 17, 0, input);
 2289  
 
 2290  0
                 throw nvae;
 2291  
 
 2292  
             }
 2293  28
 
 2294  112
             switch (alt17) {
 2295  
                 case 1 :
 2296  70
                     // com\\googlecode\\sparkleg\\Sparql.g:140:17: (v+= varOrIRIref )+
 2297  70
                     {
 2298  
                     // com\\googlecode\\sparkleg\\Sparql.g:140:17: (v+= varOrIRIref )+
 2299  112
                     int cnt16=0;
 2300  
                     loop16:
 2301  
                     do {
 2302  280
                         int alt16=2;
 2303  280
                         switch ( input.LA(1) ) {
 2304  42
                         case IRI_REF:
 2305  
                         case PNAME_LN:
 2306  
                         case PNAME_NS:
 2307  
                         case VAR1:
 2308  
                         case VAR2:
 2309  
                             {
 2310  238
                             alt16=1;
 2311  
                             }
 2312  
                             break;
 2313  
 
 2314  42
                         }
 2315  42
 
 2316  280
                         switch (alt16) {
 2317  42
                             case 1 :
 2318  
                                 // com\\googlecode\\sparkleg\\Sparql.g:140:18: v+= varOrIRIref
 2319  42
                                 {
 2320  210
                                 pushFollow(FOLLOW_varOrIRIref_in_describeQuery747);
 2321  210
                                 v=varOrIRIref();
 2322  
 
 2323  168
                                 state._fsp--;
 2324  
 
 2325  210
                                 stream_varOrIRIref.add(v.getTree());
 2326  168
                                 if (list_v==null) list_v=new ArrayList();
 2327  168
                                 list_v.add(v.getTree());
 2328  28
 
 2329  
 
 2330  
                                 }
 2331  168
                                 break;
 2332  
 
 2333  42
                             default :
 2334  154
                                 if ( cnt16 >= 1 ) break loop16;
 2335  0
                                 EarlyExitException eee =
 2336  
                                     new EarlyExitException(16, input);
 2337  0
                                 throw eee;
 2338  28
                         }
 2339  168
                         cnt16++;
 2340  168
                     } while (true);
 2341  
 
 2342  
 
 2343  
                     }
 2344  112
                     break;
 2345  
                 case 2 :
 2346  
                     // com\\googlecode\\sparkleg\\Sparql.g:140:37: '*'
 2347  
                     {
 2348  0
                     char_literal52=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery753);  
 2349  0
                     stream_ASTERISK.add(char_literal52);
 2350  
 
 2351  
 
 2352  
                     }
 2353  
                     break;
 2354  
 
 2355  28
             }
 2356  28
 
 2357  
 
 2358  
             // com\\googlecode\\sparkleg\\Sparql.g:140:42: ( datasetClause )*
 2359  
             loop18:
 2360  
             do {
 2361  112
                 int alt18=2;
 2362  112
                 switch ( input.LA(1) ) {
 2363  
                 case FROM:
 2364  
                     {
 2365  28
                     alt18=1;
 2366  
                     }
 2367  
                     break;
 2368  
 
 2369  
                 }
 2370  
 
 2371  112
                 switch (alt18) {
 2372  
                     case 1 :
 2373  
                         // com\\googlecode\\sparkleg\\Sparql.g:140:42: datasetClause
 2374  
                         {
 2375  0
                         pushFollow(FOLLOW_datasetClause_in_describeQuery756);
 2376  0
                         datasetClause53=datasetClause();
 2377  
 
 2378  0
                         state._fsp--;
 2379  
 
 2380  28
                         stream_datasetClause.add(datasetClause53.getTree());
 2381  
 
 2382  
                         }
 2383  0
                         break;
 2384  
 
 2385  
                     default :
 2386  140
                         break loop18;
 2387  28
                 }
 2388  0
             } while (true);
 2389  
 
 2390  
 
 2391  22
             // com\\googlecode\\sparkleg\\Sparql.g:140:57: ( whereClause )?
 2392  112
             int alt19=2;
 2393  112
             switch ( input.LA(1) ) {
 2394  
                 case WHERE:
 2395  
                 case 216:
 2396  28
                     {
 2397  88
                     alt19=1;
 2398  
                     }
 2399  
                     break;
 2400  22
             }
 2401  22
 
 2402  112
             switch (alt19) {
 2403  22
                 case 1 :
 2404  
                     // com\\googlecode\\sparkleg\\Sparql.g:140:57: whereClause
 2405  22
                     {
 2406  88
                     pushFollow(FOLLOW_whereClause_in_describeQuery759);
 2407  88
                     whereClause54=whereClause();
 2408  
 
 2409  88
                     state._fsp--;
 2410  
 
 2411  88
                     stream_whereClause.add(whereClause54.getTree());
 2412  
 
 2413  28
                     }
 2414  28
                     break;
 2415  
 
 2416  28
             }
 2417  
 
 2418  28
 
 2419  112
             pushFollow(FOLLOW_solutionModifier_in_describeQuery762);
 2420  112
             solutionModifier55=solutionModifier();
 2421  
 
 2422  112
             state._fsp--;
 2423  
 
 2424  112
             stream_solutionModifier.add(solutionModifier55.getTree());
 2425  
 
 2426  
             // AST REWRITE
 2427  28
             // elements: whereClause, solutionModifier, v, datasetClause, DESCRIBE, ASTERISK
 2428  28
             // token labels: 
 2429  28
             // rule labels: retval
 2430  28
             // token list labels: 
 2431  
             // rule list labels: v
 2432  
             // wildcard labels: 
 2433  112
             retval.tree = root_0;
 2434  112
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2435  140
             RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 2436  140
             root_0 = (Object)adaptor.nil();
 2437  
             // 140:87: -> ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2438  
             {
 2439  
                 // com\\googlecode\\sparkleg\\Sparql.g:140:90: ^( DESCRIBE ( $v)* ( '*' )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2440  
                 {
 2441  182
                 Object root_1 = (Object)adaptor.nil();
 2442  154
                 root_1 = (Object)adaptor.becomeRoot(
 2443  
                 stream_DESCRIBE.nextNode()
 2444  
                 , root_1);
 2445  28
 
 2446  
                 // com\\googlecode\\sparkleg\\Sparql.g:140:102: ( $v)*
 2447  280
                 while ( stream_v.hasNext() ) {
 2448  196
                     adaptor.addChild(root_1, stream_v.nextTree());
 2449  
 
 2450  
                 }
 2451  112
                 stream_v.reset();
 2452  
 
 2453  
                 // com\\googlecode\\sparkleg\\Sparql.g:140:105: ( '*' )*
 2454  140
                 while ( stream_ASTERISK.hasNext() ) {
 2455  0
                     adaptor.addChild(root_1, 
 2456  
                     stream_ASTERISK.nextNode()
 2457  28
                     );
 2458  
 
 2459  
                 }
 2460  112
                 stream_ASTERISK.reset();
 2461  28
 
 2462  
                 // com\\googlecode\\sparkleg\\Sparql.g:140:110: ( datasetClause )*
 2463  112
                 while ( stream_datasetClause.hasNext() ) {
 2464  28
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2465  22
 
 2466  
                 }
 2467  112
                 stream_datasetClause.reset();
 2468  28
 
 2469  
                 // com\\googlecode\\sparkleg\\Sparql.g:140:125: ( whereClause )?
 2470  112
                 if ( stream_whereClause.hasNext() ) {
 2471  116
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 2472  
 
 2473  
                 }
 2474  112
                 stream_whereClause.reset();
 2475  28
 
 2476  
                 // com\\googlecode\\sparkleg\\Sparql.g:140:138: ( solutionModifier )*
 2477  140
                 while ( stream_solutionModifier.hasNext() ) {
 2478  0
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2479  
 
 2480  
                 }
 2481  112
                 stream_solutionModifier.reset();
 2482  
 
 2483  140
                 adaptor.addChild(root_0, root_1);
 2484  
                 }
 2485  
 
 2486  
             }
 2487  28
 
 2488  
 
 2489  112
             retval.tree = root_0;
 2490  28
 
 2491  28
             }
 2492  
 
 2493  112
             retval.stop = input.LT(-1);
 2494  
 
 2495  
 
 2496  112
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2497  112
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2498  
 
 2499  
         }
 2500  0
         catch (RecognitionException re) {
 2501  0
             reportError(re);
 2502  0
             recover(input,re);
 2503  28
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2504  28
 
 2505  
         }
 2506  
 
 2507  0
         finally {
 2508  
                 // do for sure before leaving
 2509  112
         }
 2510  112
         return retval;
 2511  120
     }
 2512  
     // $ANTLR end "describeQuery"
 2513  
 
 2514  
 
 2515  486
     public static class askQuery_return extends ParserRuleReturnScope {
 2516  
         Object tree;
 2517  486
         public Object getTree() { return tree; }
 2518  120
     };
 2519  120
 
 2520  
 
 2521  
     // $ANTLR start "askQuery"
 2522  120
     // com\\googlecode\\sparkleg\\Sparql.g:143:1: askQuery : ASK ( datasetClause )* whereClause solutionModifier -> ^( ASK ( datasetClause )* whereClause ( solutionModifier )* ) ;
 2523  
     public final SparqlParser.askQuery_return askQuery() throws RecognitionException {
 2524  606
         SparqlParser.askQuery_return retval = new SparqlParser.askQuery_return();
 2525  606
         retval.start = input.LT(1);
 2526  
 
 2527  120
 
 2528  486
         Object root_0 = null;
 2529  120
 
 2530  486
         Token ASK56=null;
 2531  486
         SparqlParser.datasetClause_return datasetClause57 =null;
 2532  120
 
 2533  606
         SparqlParser.whereClause_return whereClause58 =null;
 2534  120
 
 2535  606
         SparqlParser.solutionModifier_return solutionModifier59 =null;
 2536  120
 
 2537  
 
 2538  486
         Object ASK56_tree=null;
 2539  486
         RewriteRuleTokenStream stream_ASK=new RewriteRuleTokenStream(adaptor,"token ASK");
 2540  486
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2541  606
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2542  606
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2543  
         try {
 2544  
             // com\\googlecode\\sparkleg\\Sparql.g:144:5: ( ASK ( datasetClause )* whereClause solutionModifier -> ^( ASK ( datasetClause )* whereClause ( solutionModifier )* ) )
 2545  
             // com\\googlecode\\sparkleg\\Sparql.g:144:7: ASK ( datasetClause )* whereClause solutionModifier
 2546  
             {
 2547  486
             ASK56=(Token)match(input,ASK,FOLLOW_ASK_in_askQuery801);  
 2548  606
             stream_ASK.add(ASK56);
 2549  120
 
 2550  
 
 2551  
             // com\\googlecode\\sparkleg\\Sparql.g:144:11: ( datasetClause )*
 2552  
             loop20:
 2553  
             do {
 2554  486
                 int alt20=2;
 2555  486
                 switch ( input.LA(1) ) {
 2556  
                 case FROM:
 2557  
                     {
 2558  120
                     alt20=1;
 2559  
                     }
 2560  
                     break;
 2561  
 
 2562  
                 }
 2563  
 
 2564  486
                 switch (alt20) {
 2565  
                     case 1 :
 2566  
                         // com\\googlecode\\sparkleg\\Sparql.g:144:11: datasetClause
 2567  
                         {
 2568  0
                         pushFollow(FOLLOW_datasetClause_in_askQuery803);
 2569  0
                         datasetClause57=datasetClause();
 2570  
 
 2571  0
                         state._fsp--;
 2572  
 
 2573  120
                         stream_datasetClause.add(datasetClause57.getTree());
 2574  
 
 2575  
                         }
 2576  0
                         break;
 2577  
 
 2578  120
                     default :
 2579  606
                         break loop20;
 2580  
                 }
 2581  120
             } while (true);
 2582  
 
 2583  120
 
 2584  486
             pushFollow(FOLLOW_whereClause_in_askQuery806);
 2585  606
             whereClause58=whereClause();
 2586  120
 
 2587  486
             state._fsp--;
 2588  120
 
 2589  486
             stream_whereClause.add(whereClause58.getTree());
 2590  120
 
 2591  486
             pushFollow(FOLLOW_solutionModifier_in_askQuery808);
 2592  486
             solutionModifier59=solutionModifier();
 2593  
 
 2594  486
             state._fsp--;
 2595  
 
 2596  486
             stream_solutionModifier.add(solutionModifier59.getTree());
 2597  
 
 2598  
             // AST REWRITE
 2599  120
             // elements: whereClause, solutionModifier, datasetClause, ASK
 2600  120
             // token labels: 
 2601  
             // rule labels: retval
 2602  120
             // token list labels: 
 2603  
             // rule list labels: 
 2604  
             // wildcard labels: 
 2605  486
             retval.tree = root_0;
 2606  486
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2607  120
 
 2608  606
             root_0 = (Object)adaptor.nil();
 2609  
             // 144:55: -> ^( ASK ( datasetClause )* whereClause ( solutionModifier )* )
 2610  
             {
 2611  
                 // com\\googlecode\\sparkleg\\Sparql.g:144:58: ^( ASK ( datasetClause )* whereClause ( solutionModifier )* )
 2612  
                 {
 2613  606
                 Object root_1 = (Object)adaptor.nil();
 2614  486
                 root_1 = (Object)adaptor.becomeRoot(
 2615  
                 stream_ASK.nextNode()
 2616  
                 , root_1);
 2617  120
 
 2618  
                 // com\\googlecode\\sparkleg\\Sparql.g:144:64: ( datasetClause )*
 2619  606
                 while ( stream_datasetClause.hasNext() ) {
 2620  0
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2621  
 
 2622  120
                 }
 2623  486
                 stream_datasetClause.reset();
 2624  
 
 2625  486
                 adaptor.addChild(root_1, stream_whereClause.nextTree());
 2626  120
 
 2627  
                 // com\\googlecode\\sparkleg\\Sparql.g:144:91: ( solutionModifier )*
 2628  606
                 while ( stream_solutionModifier.hasNext() ) {
 2629  0
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2630  
 
 2631  
                 }
 2632  486
                 stream_solutionModifier.reset();
 2633  
 
 2634  606
                 adaptor.addChild(root_0, root_1);
 2635  
                 }
 2636  
 
 2637  
             }
 2638  120
 
 2639  
 
 2640  486
             retval.tree = root_0;
 2641  120
 
 2642  120
             }
 2643  
 
 2644  486
             retval.stop = input.LT(-1);
 2645  
 
 2646  
 
 2647  486
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2648  486
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2649  
 
 2650  
         }
 2651  0
         catch (RecognitionException re) {
 2652  0
             reportError(re);
 2653  0
             recover(input,re);
 2654  120
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2655  120
 
 2656  
         }
 2657  
 
 2658  0
         finally {
 2659  
                 // do for sure before leaving
 2660  160
         }
 2661  486
         return retval;
 2662  160
     }
 2663  
     // $ANTLR end "askQuery"
 2664  
 
 2665  
 
 2666  640
     public static class datasetClause_return extends ParserRuleReturnScope {
 2667  
         Object tree;
 2668  640
         public Object getTree() { return tree; }
 2669  160
     };
 2670  160
 
 2671  
 
 2672  
     // $ANTLR start "datasetClause"
 2673  160
     // com\\googlecode\\sparkleg\\Sparql.g:147:1: datasetClause : FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) ;
 2674  
     public final SparqlParser.datasetClause_return datasetClause() throws RecognitionException {
 2675  800
         SparqlParser.datasetClause_return retval = new SparqlParser.datasetClause_return();
 2676  800
         retval.start = input.LT(1);
 2677  160
 
 2678  
 
 2679  640
         Object root_0 = null;
 2680  160
 
 2681  800
         Token FROM60=null;
 2682  800
         Token NAMED61=null;
 2683  800
         SparqlParser.iriRef_return iriRef62 =null;
 2684  160
 
 2685  
 
 2686  640
         Object FROM60_tree=null;
 2687  640
         Object NAMED61_tree=null;
 2688  640
         RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
 2689  800
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 2690  800
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 2691  
         try {
 2692  
             // com\\googlecode\\sparkleg\\Sparql.g:148:5: ( FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) )
 2693  
             // com\\googlecode\\sparkleg\\Sparql.g:148:7: FROM ( NAMED )? iriRef
 2694  160
             {
 2695  800
             FROM60=(Token)match(input,FROM,FOLLOW_FROM_in_datasetClause839);  
 2696  640
             stream_FROM.add(FROM60);
 2697  
 
 2698  102
 
 2699  
             // com\\googlecode\\sparkleg\\Sparql.g:148:12: ( NAMED )?
 2700  640
             int alt21=2;
 2701  640
             switch ( input.LA(1) ) {
 2702  
                 case NAMED:
 2703  160
                     {
 2704  408
                     alt21=1;
 2705  
                     }
 2706  
                     break;
 2707  102
             }
 2708  102
 
 2709  640
             switch (alt21) {
 2710  
                 case 1 :
 2711  
                     // com\\googlecode\\sparkleg\\Sparql.g:148:12: NAMED
 2712  
                     {
 2713  408
                     NAMED61=(Token)match(input,NAMED,FOLLOW_NAMED_in_datasetClause841);  
 2714  408
                     stream_NAMED.add(NAMED61);
 2715  
 
 2716  
 
 2717  160
                     }
 2718  160
                     break;
 2719  
 
 2720  160
             }
 2721  
 
 2722  160
 
 2723  640
             pushFollow(FOLLOW_iriRef_in_datasetClause844);
 2724  640
             iriRef62=iriRef();
 2725  
 
 2726  640
             state._fsp--;
 2727  
 
 2728  640
             stream_iriRef.add(iriRef62.getTree());
 2729  
 
 2730  
             // AST REWRITE
 2731  160
             // elements: iriRef, FROM, NAMED
 2732  160
             // token labels: 
 2733  
             // rule labels: retval
 2734  160
             // token list labels: 
 2735  
             // rule list labels: 
 2736  
             // wildcard labels: 
 2737  640
             retval.tree = root_0;
 2738  640
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2739  160
 
 2740  800
             root_0 = (Object)adaptor.nil();
 2741  
             // 148:26: -> ^( FROM ( NAMED )? iriRef )
 2742  
             {
 2743  
                 // com\\googlecode\\sparkleg\\Sparql.g:148:29: ^( FROM ( NAMED )? iriRef )
 2744  
                 {
 2745  800
                 Object root_1 = (Object)adaptor.nil();
 2746  742
                 root_1 = (Object)adaptor.becomeRoot(
 2747  
                 stream_FROM.nextNode()
 2748  
                 , root_1);
 2749  
 
 2750  
                 // com\\googlecode\\sparkleg\\Sparql.g:148:36: ( NAMED )?
 2751  800
                 if ( stream_NAMED.hasNext() ) {
 2752  408
                     adaptor.addChild(root_1, 
 2753  160
                     stream_NAMED.nextNode()
 2754  
                     );
 2755  160
 
 2756  
                 }
 2757  640
                 stream_NAMED.reset();
 2758  
 
 2759  640
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 2760  
 
 2761  800
                 adaptor.addChild(root_0, root_1);
 2762  
                 }
 2763  
 
 2764  
             }
 2765  160
 
 2766  
 
 2767  640
             retval.tree = root_0;
 2768  160
 
 2769  160
             }
 2770  
 
 2771  640
             retval.stop = input.LT(-1);
 2772  
 
 2773  
 
 2774  640
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2775  640
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2776  
 
 2777  
         }
 2778  0
         catch (RecognitionException re) {
 2779  0
             reportError(re);
 2780  0
             recover(input,re);
 2781  160
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2782  160
 
 2783  
         }
 2784  
 
 2785  0
         finally {
 2786  
                 // do for sure before leaving
 2787  640
         }
 2788  640
         return retval;
 2789  1856
     }
 2790  
     // $ANTLR end "datasetClause"
 2791  
 
 2792  
 
 2793  7250
     public static class whereClause_return extends ParserRuleReturnScope {
 2794  
         Object tree;
 2795  7250
         public Object getTree() { return tree; }
 2796  1856
     };
 2797  1856
 
 2798  
 
 2799  
     // $ANTLR start "whereClause"
 2800  1856
     // com\\googlecode\\sparkleg\\Sparql.g:151:1: whereClause : ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) ;
 2801  
     public final SparqlParser.whereClause_return whereClause() throws RecognitionException {
 2802  9106
         SparqlParser.whereClause_return retval = new SparqlParser.whereClause_return();
 2803  9106
         retval.start = input.LT(1);
 2804  
 
 2805  
 
 2806  9106
         Object root_0 = null;
 2807  1856
 
 2808  9106
         Token WHERE63=null;
 2809  7250
         SparqlParser.groupGraphPattern_return groupGraphPattern64 =null;
 2810  
 
 2811  
 
 2812  7250
         Object WHERE63_tree=null;
 2813  7250
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 2814  9106
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 2815  1856
         try {
 2816  
             // com\\googlecode\\sparkleg\\Sparql.g:152:5: ( ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) )
 2817  
             // com\\googlecode\\sparkleg\\Sparql.g:152:7: ( WHERE )? groupGraphPattern
 2818  1356
             {
 2819  
             // com\\googlecode\\sparkleg\\Sparql.g:152:7: ( WHERE )?
 2820  7250
             int alt22=2;
 2821  7250
             switch ( input.LA(1) ) {
 2822  
                 case WHERE:
 2823  1856
                     {
 2824  6015
                     alt22=1;
 2825  
                     }
 2826  
                     break;
 2827  1356
             }
 2828  1356
 
 2829  7250
             switch (alt22) {
 2830  
                 case 1 :
 2831  
                     // com\\googlecode\\sparkleg\\Sparql.g:152:7: WHERE
 2832  
                     {
 2833  6015
                     WHERE63=(Token)match(input,WHERE,FOLLOW_WHERE_in_whereClause872);  
 2834  6015
                     stream_WHERE.add(WHERE63);
 2835  
 
 2836  
 
 2837  1856
                     }
 2838  1856
                     break;
 2839  
 
 2840  1856
             }
 2841  
 
 2842  1856
 
 2843  7250
             pushFollow(FOLLOW_groupGraphPattern_in_whereClause875);
 2844  7250
             groupGraphPattern64=groupGraphPattern();
 2845  
 
 2846  7250
             state._fsp--;
 2847  
 
 2848  7250
             stream_groupGraphPattern.add(groupGraphPattern64.getTree());
 2849  
 
 2850  
             // AST REWRITE
 2851  1856
             // elements: groupGraphPattern
 2852  1856
             // token labels: 
 2853  
             // rule labels: retval
 2854  1856
             // token list labels: 
 2855  
             // rule list labels: 
 2856  
             // wildcard labels: 
 2857  7250
             retval.tree = root_0;
 2858  7250
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2859  1856
 
 2860  9106
             root_0 = (Object)adaptor.nil();
 2861  
             // 152:32: -> ^( WHERE_CLAUSE groupGraphPattern )
 2862  
             {
 2863  
                 // com\\googlecode\\sparkleg\\Sparql.g:152:35: ^( WHERE_CLAUSE groupGraphPattern )
 2864  1856
                 {
 2865  7250
                 Object root_1 = (Object)adaptor.nil();
 2866  9106
                 root_1 = (Object)adaptor.becomeRoot(
 2867  
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2868  
                 , root_1);
 2869  
 
 2870  7250
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 2871  
 
 2872  9106
                 adaptor.addChild(root_0, root_1);
 2873  
                 }
 2874  
 
 2875  
             }
 2876  1856
 
 2877  
 
 2878  7250
             retval.tree = root_0;
 2879  1856
 
 2880  1856
             }
 2881  
 
 2882  7250
             retval.stop = input.LT(-1);
 2883  
 
 2884  
 
 2885  7250
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2886  7250
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2887  
 
 2888  
         }
 2889  0
         catch (RecognitionException re) {
 2890  0
             reportError(re);
 2891  0
             recover(input,re);
 2892  1856
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2893  1856
 
 2894  
         }
 2895  
 
 2896  0
         finally {
 2897  
                 // do for sure before leaving
 2898  7250
         }
 2899  7250
         return retval;
 2900  1874
     }
 2901  
     // $ANTLR end "whereClause"
 2902  
 
 2903  
 
 2904  7322
     public static class solutionModifier_return extends ParserRuleReturnScope {
 2905  
         Object tree;
 2906  7322
         public Object getTree() { return tree; }
 2907  1874
     };
 2908  1874
 
 2909  
 
 2910  
     // $ANTLR start "solutionModifier"
 2911  1874
     // com\\googlecode\\sparkleg\\Sparql.g:155:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* ;
 2912  
     public final SparqlParser.solutionModifier_return solutionModifier() throws RecognitionException {
 2913  9196
         SparqlParser.solutionModifier_return retval = new SparqlParser.solutionModifier_return();
 2914  7322
         retval.start = input.LT(1);
 2915  1874
 
 2916  
 
 2917  9196
         Object root_0 = null;
 2918  
 
 2919  9196
         SparqlParser.groupClause_return groupClause65 =null;
 2920  
 
 2921  7322
         SparqlParser.havingClause_return havingClause66 =null;
 2922  1874
 
 2923  9196
         SparqlParser.orderClause_return orderClause67 =null;
 2924  1874
 
 2925  9196
         SparqlParser.limitOffsetClauses_return limitOffsetClauses68 =null;
 2926  
 
 2927  
 
 2928  7322
         RewriteRuleSubtreeStream stream_limitOffsetClauses=new RewriteRuleSubtreeStream(adaptor,"rule limitOffsetClauses");
 2929  7322
         RewriteRuleSubtreeStream stream_orderClause=new RewriteRuleSubtreeStream(adaptor,"rule orderClause");
 2930  7322
         RewriteRuleSubtreeStream stream_groupClause=new RewriteRuleSubtreeStream(adaptor,"rule groupClause");
 2931  9196
         RewriteRuleSubtreeStream stream_havingClause=new RewriteRuleSubtreeStream(adaptor,"rule havingClause");
 2932  1874
         try {
 2933  
             // com\\googlecode\\sparkleg\\Sparql.g:156:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* )
 2934  
             // com\\googlecode\\sparkleg\\Sparql.g:156:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2935  66
             {
 2936  
             // com\\googlecode\\sparkleg\\Sparql.g:156:7: ( groupClause )?
 2937  7322
             int alt23=2;
 2938  7322
             switch ( input.LA(1) ) {
 2939  
                 case GROUP:
 2940  1874
                     {
 2941  264
                     alt23=1;
 2942  
                     }
 2943  
                     break;
 2944  66
             }
 2945  66
 
 2946  7322
             switch (alt23) {
 2947  66
                 case 1 :
 2948  
                     // com\\googlecode\\sparkleg\\Sparql.g:156:7: groupClause
 2949  66
                     {
 2950  264
                     pushFollow(FOLLOW_groupClause_in_solutionModifier900);
 2951  264
                     groupClause65=groupClause();
 2952  
 
 2953  264
                     state._fsp--;
 2954  
 
 2955  264
                     stream_groupClause.add(groupClause65.getTree());
 2956  
 
 2957  
                     }
 2958  1874
                     break;
 2959  1874
 
 2960  
             }
 2961  
 
 2962  16
 
 2963  
             // com\\googlecode\\sparkleg\\Sparql.g:156:20: ( havingClause )?
 2964  7322
             int alt24=2;
 2965  7322
             switch ( input.LA(1) ) {
 2966  
                 case HAVING:
 2967  1874
                     {
 2968  64
                     alt24=1;
 2969  
                     }
 2970  
                     break;
 2971  16
             }
 2972  16
 
 2973  7322
             switch (alt24) {
 2974  16
                 case 1 :
 2975  
                     // com\\googlecode\\sparkleg\\Sparql.g:156:20: havingClause
 2976  16
                     {
 2977  64
                     pushFollow(FOLLOW_havingClause_in_solutionModifier903);
 2978  64
                     havingClause66=havingClause();
 2979  
 
 2980  64
                     state._fsp--;
 2981  
 
 2982  64
                     stream_havingClause.add(havingClause66.getTree());
 2983  
 
 2984  
                     }
 2985  1874
                     break;
 2986  1874
 
 2987  
             }
 2988  
 
 2989  134
 
 2990  
             // com\\googlecode\\sparkleg\\Sparql.g:156:34: ( orderClause )?
 2991  7322
             int alt25=2;
 2992  7322
             switch ( input.LA(1) ) {
 2993  
                 case ORDER:
 2994  1874
                     {
 2995  536
                     alt25=1;
 2996  
                     }
 2997  
                     break;
 2998  134
             }
 2999  134
 
 3000  7322
             switch (alt25) {
 3001  134
                 case 1 :
 3002  
                     // com\\googlecode\\sparkleg\\Sparql.g:156:34: orderClause
 3003  134
                     {
 3004  536
                     pushFollow(FOLLOW_orderClause_in_solutionModifier906);
 3005  536
                     orderClause67=orderClause();
 3006  
 
 3007  536
                     state._fsp--;
 3008  
 
 3009  536
                     stream_orderClause.add(orderClause67.getTree());
 3010  
 
 3011  
                     }
 3012  1874
                     break;
 3013  1874
 
 3014  
             }
 3015  
 
 3016  
 
 3017  58
             // com\\googlecode\\sparkleg\\Sparql.g:156:47: ( limitOffsetClauses )?
 3018  7322
             int alt26=2;
 3019  7322
             switch ( input.LA(1) ) {
 3020  
                 case LIMIT:
 3021  
                 case OFFSET:
 3022  1874
                     {
 3023  232
                     alt26=1;
 3024  
                     }
 3025  
                     break;
 3026  58
             }
 3027  58
 
 3028  7322
             switch (alt26) {
 3029  58
                 case 1 :
 3030  
                     // com\\googlecode\\sparkleg\\Sparql.g:156:47: limitOffsetClauses
 3031  58
                     {
 3032  232
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier909);
 3033  232
                     limitOffsetClauses68=limitOffsetClauses();
 3034  
 
 3035  232
                     state._fsp--;
 3036  
 
 3037  232
                     stream_limitOffsetClauses.add(limitOffsetClauses68.getTree());
 3038  
 
 3039  
                     }
 3040  
                     break;
 3041  
 
 3042  
             }
 3043  
 
 3044  
 
 3045  
             // AST REWRITE
 3046  1874
             // elements: havingClause, limitOffsetClauses, groupClause, orderClause
 3047  1874
             // token labels: 
 3048  
             // rule labels: retval
 3049  1874
             // token list labels: 
 3050  
             // rule list labels: 
 3051  
             // wildcard labels: 
 3052  7322
             retval.tree = root_0;
 3053  9262
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3054  66
 
 3055  7322
             root_0 = (Object)adaptor.nil();
 3056  
             // 156:67: -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )*
 3057  1874
             {
 3058  
                 // com\\googlecode\\sparkleg\\Sparql.g:156:70: ( groupClause )*
 3059  7586
                 while ( stream_groupClause.hasNext() ) {
 3060  2154
                     adaptor.addChild(root_0, stream_groupClause.nextTree());
 3061  16
 
 3062  
                 }
 3063  7322
                 stream_groupClause.reset();
 3064  1874
 
 3065  
                 // com\\googlecode\\sparkleg\\Sparql.g:156:83: ( havingClause )*
 3066  7386
                 while ( stream_havingClause.hasNext() ) {
 3067  2072
                     adaptor.addChild(root_0, stream_havingClause.nextTree());
 3068  134
 
 3069  
                 }
 3070  7322
                 stream_havingClause.reset();
 3071  1874
 
 3072  
                 // com\\googlecode\\sparkleg\\Sparql.g:156:97: ( orderClause )*
 3073  7858
                 while ( stream_orderClause.hasNext() ) {
 3074  2468
                     adaptor.addChild(root_0, stream_orderClause.nextTree());
 3075  58
 
 3076  
                 }
 3077  7322
                 stream_orderClause.reset();
 3078  1874
 
 3079  
                 // com\\googlecode\\sparkleg\\Sparql.g:156:110: ( limitOffsetClauses )*
 3080  7554
                 while ( stream_limitOffsetClauses.hasNext() ) {
 3081  232
                     adaptor.addChild(root_0, stream_limitOffsetClauses.nextTree());
 3082  
 
 3083  1874
                 }
 3084  7322
                 stream_limitOffsetClauses.reset();
 3085  
 
 3086  
             }
 3087  1874
 
 3088  
 
 3089  7322
             retval.tree = root_0;
 3090  1874
 
 3091  1874
             }
 3092  
 
 3093  7322
             retval.stop = input.LT(-1);
 3094  
 
 3095  
 
 3096  7322
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3097  7322
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3098  
 
 3099  
         }
 3100  0
         catch (RecognitionException re) {
 3101  0
             reportError(re);
 3102  0
             recover(input,re);
 3103  1874
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3104  1874
 
 3105  
         }
 3106  
 
 3107  0
         finally {
 3108  
                 // do for sure before leaving
 3109  66
         }
 3110  7322
         return retval;
 3111  66
     }
 3112  
     // $ANTLR end "solutionModifier"
 3113  
 
 3114  
 
 3115  264
     public static class groupClause_return extends ParserRuleReturnScope {
 3116  
         Object tree;
 3117  264
         public Object getTree() { return tree; }
 3118  66
     };
 3119  66
 
 3120  
 
 3121  
     // $ANTLR start "groupClause"
 3122  66
     // com\\googlecode\\sparkleg\\Sparql.g:159:1: groupClause : GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) ;
 3123  
     public final SparqlParser.groupClause_return groupClause() throws RecognitionException {
 3124  330
         SparqlParser.groupClause_return retval = new SparqlParser.groupClause_return();
 3125  330
         retval.start = input.LT(1);
 3126  66
 
 3127  
 
 3128  264
         Object root_0 = null;
 3129  66
 
 3130  330
         Token GROUP69=null;
 3131  330
         Token BY70=null;
 3132  330
         SparqlParser.groupCondition_return groupCondition71 =null;
 3133  66
 
 3134  
 
 3135  264
         Object GROUP69_tree=null;
 3136  264
         Object BY70_tree=null;
 3137  264
         RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
 3138  330
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3139  330
         RewriteRuleSubtreeStream stream_groupCondition=new RewriteRuleSubtreeStream(adaptor,"rule groupCondition");
 3140  
         try {
 3141  
             // com\\googlecode\\sparkleg\\Sparql.g:160:5: ( GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) )
 3142  66
             // com\\googlecode\\sparkleg\\Sparql.g:160:7: GROUP BY ( groupCondition )+
 3143  66
             {
 3144  264
             GROUP69=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupClause941);  
 3145  264
             stream_GROUP.add(GROUP69);
 3146  
 
 3147  66
 
 3148  264
             BY70=(Token)match(input,BY,FOLLOW_BY_in_groupClause943);  
 3149  264
             stream_BY.add(BY70);
 3150  136
 
 3151  136
 
 3152  
             // com\\googlecode\\sparkleg\\Sparql.g:160:16: ( groupCondition )+
 3153  264
             int cnt27=0;
 3154  
             loop27:
 3155  
             do {
 3156  544
                 int alt27=2;
 3157  544
                 switch ( input.LA(1) ) {
 3158  
                 case ABS:
 3159  
                 case BNODE:
 3160  
                 case BOUND:
 3161  
                 case CEIL:
 3162  
                 case COALESCE:
 3163  
                 case CONCAT:
 3164  
                 case CONTAINS:
 3165  
                 case DATATYPE:
 3166  
                 case DAY:
 3167  
                 case ENCODE_FOR_URI:
 3168  
                 case EXISTS:
 3169  
                 case FLOOR:
 3170  
                 case HOURS:
 3171  
                 case IF:
 3172  
                 case IRI:
 3173  
                 case IRI_REF:
 3174  
                 case ISBLANK:
 3175  
                 case ISIRI:
 3176  
                 case ISLITERAL:
 3177  
                 case ISNUMERIC:
 3178  
                 case ISURI:
 3179  
                 case LANG:
 3180  
                 case LANGMATCHES:
 3181  
                 case LCASE:
 3182  
                 case MD5:
 3183  
                 case MINUTES:
 3184  
                 case MONTH:
 3185  
                 case NOT:
 3186  
                 case NOW:
 3187  
                 case PNAME_LN:
 3188  
                 case PNAME_NS:
 3189  
                 case RAND:
 3190  
                 case REGEX:
 3191  
                 case REPLACE:
 3192  
                 case ROUND:
 3193  
                 case SAMETERM:
 3194  
                 case SECONDS:
 3195  
                 case SHA1:
 3196  
                 case SHA256:
 3197  
                 case SHA384:
 3198  
                 case SHA512:
 3199  
                 case STR:
 3200  
                 case STRAFTER:
 3201  
                 case STRBEFORE:
 3202  
                 case STRDT:
 3203  
                 case STRENDS:
 3204  
                 case STRLANG:
 3205  
                 case STRLEN:
 3206  
                 case STRSTARTS:
 3207  
                 case SUBSTR:
 3208  
                 case TIMEZONE:
 3209  
                 case TZ:
 3210  
                 case UCASE:
 3211  70
                 case URI:
 3212  
                 case VAR1:
 3213  
                 case VAR2:
 3214  
                 case YEAR:
 3215  
                 case 209:
 3216  
                     {
 3217  416
                     alt27=1;
 3218  
                     }
 3219  
                     break;
 3220  
 
 3221  70
                 }
 3222  70
 
 3223  544
                 switch (alt27) {
 3224  70
                     case 1 :
 3225  
                         // com\\googlecode\\sparkleg\\Sparql.g:160:16: groupCondition
 3226  70
                         {
 3227  280
                         pushFollow(FOLLOW_groupCondition_in_groupClause945);
 3228  280
                         groupCondition71=groupCondition();
 3229  70
 
 3230  280
                         state._fsp--;
 3231  
 
 3232  346
                         stream_groupCondition.add(groupCondition71.getTree());
 3233  
 
 3234  
                         }
 3235  280
                         break;
 3236  
 
 3237  70
                     default :
 3238  334
                         if ( cnt27 >= 1 ) break loop27;
 3239  0
                         EarlyExitException eee =
 3240  
                             new EarlyExitException(27, input);
 3241  0
                         throw eee;
 3242  
                 }
 3243  280
                 cnt27++;
 3244  280
             } while (true);
 3245  
 
 3246  
 
 3247  
             // AST REWRITE
 3248  66
             // elements: groupCondition
 3249  66
             // token labels: 
 3250  
             // rule labels: retval
 3251  66
             // token list labels: 
 3252  
             // rule list labels: 
 3253  
             // wildcard labels: 
 3254  264
             retval.tree = root_0;
 3255  264
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3256  66
 
 3257  330
             root_0 = (Object)adaptor.nil();
 3258  
             // 160:32: -> ^( GROUP_BY ( groupCondition )+ )
 3259  
             {
 3260  
                 // com\\googlecode\\sparkleg\\Sparql.g:160:35: ^( GROUP_BY ( groupCondition )+ )
 3261  66
                 {
 3262  264
                 Object root_1 = (Object)adaptor.nil();
 3263  264
                 root_1 = (Object)adaptor.becomeRoot(
 3264  136
                 (Object)adaptor.create(GROUP_BY, "GROUP_BY")
 3265  70
                 , root_1);
 3266  
 
 3267  264
                 if ( !(stream_groupCondition.hasNext()) ) {
 3268  66
                     throw new RewriteEarlyExitException();
 3269  
                 }
 3270  610
                 while ( stream_groupCondition.hasNext() ) {
 3271  280
                     adaptor.addChild(root_1, stream_groupCondition.nextTree());
 3272  
 
 3273  
                 }
 3274  264
                 stream_groupCondition.reset();
 3275  
 
 3276  330
                 adaptor.addChild(root_0, root_1);
 3277  
                 }
 3278  
 
 3279  
             }
 3280  66
 
 3281  
 
 3282  264
             retval.tree = root_0;
 3283  66
 
 3284  66
             }
 3285  
 
 3286  264
             retval.stop = input.LT(-1);
 3287  
 
 3288  
 
 3289  264
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3290  264
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3291  
 
 3292  
         }
 3293  0
         catch (RecognitionException re) {
 3294  0
             reportError(re);
 3295  0
             recover(input,re);
 3296  66
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3297  66
 
 3298  
         }
 3299  
 
 3300  0
         finally {
 3301  
                 // do for sure before leaving
 3302  264
         }
 3303  264
         return retval;
 3304  70
     }
 3305  
     // $ANTLR end "groupClause"
 3306  
 
 3307  
 
 3308  280
     public static class groupCondition_return extends ParserRuleReturnScope {
 3309  
         Object tree;
 3310  280
         public Object getTree() { return tree; }
 3311  70
     };
 3312  70
 
 3313  
 
 3314  
     // $ANTLR start "groupCondition"
 3315  70
     // com\\googlecode\\sparkleg\\Sparql.g:163:1: groupCondition : ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | '(' expression ( AS var )? ')' -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) );
 3316  
     public final SparqlParser.groupCondition_return groupCondition() throws RecognitionException {
 3317  350
         SparqlParser.groupCondition_return retval = new SparqlParser.groupCondition_return();
 3318  350
         retval.start = input.LT(1);
 3319  70
 
 3320  70
 
 3321  280
         Object root_0 = null;
 3322  70
 
 3323  280
         Token char_literal74=null;
 3324  350
         Token AS76=null;
 3325  280
         Token char_literal78=null;
 3326  350
         SparqlParser.builtInCall_return builtInCall72 =null;
 3327  
 
 3328  350
         SparqlParser.functionCall_return functionCall73 =null;
 3329  
 
 3330  280
         SparqlParser.expression_return expression75 =null;
 3331  70
 
 3332  350
         SparqlParser.var_return var77 =null;
 3333  70
 
 3334  350
         SparqlParser.var_return var79 =null;
 3335  70
 
 3336  70
 
 3337  350
         Object char_literal74_tree=null;
 3338  350
         Object AS76_tree=null;
 3339  350
         Object char_literal78_tree=null;
 3340  350
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 3341  280
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 3342  280
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 3343  350
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 3344  350
         RewriteRuleSubtreeStream stream_functionCall=new RewriteRuleSubtreeStream(adaptor,"rule functionCall");
 3345  280
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 3346  280
         RewriteRuleSubtreeStream stream_builtInCall=new RewriteRuleSubtreeStream(adaptor,"rule builtInCall");
 3347  
         try {
 3348  
             // com\\googlecode\\sparkleg\\Sparql.g:164:5: ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | '(' expression ( AS var )? ')' -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) )
 3349  280
             int alt29=4;
 3350  280
             switch ( input.LA(1) ) {
 3351  
             case ABS:
 3352  
             case BNODE:
 3353  
             case BOUND:
 3354  
             case CEIL:
 3355  
             case COALESCE:
 3356  
             case CONCAT:
 3357  
             case CONTAINS:
 3358  
             case DATATYPE:
 3359  
             case DAY:
 3360  
             case ENCODE_FOR_URI:
 3361  
             case EXISTS:
 3362  
             case FLOOR:
 3363  
             case HOURS:
 3364  
             case IF:
 3365  
             case IRI:
 3366  
             case ISBLANK:
 3367  
             case ISIRI:
 3368  
             case ISLITERAL:
 3369  
             case ISNUMERIC:
 3370  
             case ISURI:
 3371  
             case LANG:
 3372  
             case LANGMATCHES:
 3373  
             case LCASE:
 3374  
             case MD5:
 3375  
             case MINUTES:
 3376  
             case MONTH:
 3377  
             case NOT:
 3378  
             case NOW:
 3379  
             case RAND:
 3380  
             case REGEX:
 3381  
             case REPLACE:
 3382  
             case ROUND:
 3383  
             case SAMETERM:
 3384  
             case SECONDS:
 3385  
             case SHA1:
 3386  
             case SHA256:
 3387  
             case SHA384:
 3388  
             case SHA512:
 3389  
             case STR:
 3390  
             case STRAFTER:
 3391  
             case STRBEFORE:
 3392  
             case STRDT:
 3393  
             case STRENDS:
 3394  
             case STRLANG:
 3395  
             case STRLEN:
 3396  
             case STRSTARTS:
 3397  
             case SUBSTR:
 3398  
             case TIMEZONE:
 3399  
             case TZ:
 3400  
             case UCASE:
 3401  
             case URI:
 3402  
             case YEAR:
 3403  
                 {
 3404  0
                 alt29=1;
 3405  
                 }
 3406  0
                 break;
 3407  
             case IRI_REF:
 3408  
             case PNAME_LN:
 3409  
             case PNAME_NS:
 3410  12
                 {
 3411  0
                 alt29=2;
 3412  12
                 }
 3413  0
                 break;
 3414  
             case 209:
 3415  
                 {
 3416  106
                 alt29=3;
 3417  
                 }
 3418  106
                 break;
 3419  
             case VAR1:
 3420  
             case VAR2:
 3421  
                 {
 3422  232
                 alt29=4;
 3423  
                 }
 3424  232
                 break;
 3425  
             default:
 3426  0
                 NoViableAltException nvae =
 3427  70
                     new NoViableAltException("", 29, 0, input);
 3428  
 
 3429  0
                 throw nvae;
 3430  
 
 3431  
             }
 3432  
 
 3433  280
             switch (alt29) {
 3434  
                 case 1 :
 3435  
                     // com\\googlecode\\sparkleg\\Sparql.g:164:7: builtInCall
 3436  
                     {
 3437  0
                     pushFollow(FOLLOW_builtInCall_in_groupCondition979);
 3438  0
                     builtInCall72=builtInCall();
 3439  
 
 3440  0
                     state._fsp--;
 3441  
 
 3442  0
                     stream_builtInCall.add(builtInCall72.getTree());
 3443  
 
 3444  
                     // AST REWRITE
 3445  
                     // elements: builtInCall
 3446  
                     // token labels: 
 3447  
                     // rule labels: retval
 3448  
                     // token list labels: 
 3449  
                     // rule list labels: 
 3450  
                     // wildcard labels: 
 3451  0
                     retval.tree = root_0;
 3452  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3453  
 
 3454  0
                     root_0 = (Object)adaptor.nil();
 3455  
                     // 164:19: -> ^( GROUP_CONDITION builtInCall )
 3456  
                     {
 3457  
                         // com\\googlecode\\sparkleg\\Sparql.g:164:22: ^( GROUP_CONDITION builtInCall )
 3458  
                         {
 3459  0
                         Object root_1 = (Object)adaptor.nil();
 3460  0
                         root_1 = (Object)adaptor.becomeRoot(
 3461  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3462  
                         , root_1);
 3463  
 
 3464  0
                         adaptor.addChild(root_1, stream_builtInCall.nextTree());
 3465  
 
 3466  0
                         adaptor.addChild(root_0, root_1);
 3467  
                         }
 3468  
 
 3469  
                     }
 3470  
 
 3471  
 
 3472  0
                     retval.tree = root_0;
 3473  
 
 3474  
                     }
 3475  0
                     break;
 3476  
                 case 2 :
 3477  
                     // com\\googlecode\\sparkleg\\Sparql.g:165:7: functionCall
 3478  
                     {
 3479  0
                     pushFollow(FOLLOW_functionCall_in_groupCondition995);
 3480  0
                     functionCall73=functionCall();
 3481  
 
 3482  0
                     state._fsp--;
 3483  
 
 3484  0
                     stream_functionCall.add(functionCall73.getTree());
 3485  
 
 3486  
                     // AST REWRITE
 3487  
                     // elements: functionCall
 3488  
                     // token labels: 
 3489  
                     // rule labels: retval
 3490  
                     // token list labels: 
 3491  
                     // rule list labels: 
 3492  
                     // wildcard labels: 
 3493  0
                     retval.tree = root_0;
 3494  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3495  
 
 3496  0
                     root_0 = (Object)adaptor.nil();
 3497  
                     // 165:20: -> ^( GROUP_CONDITION functionCall )
 3498  
                     {
 3499  
                         // com\\googlecode\\sparkleg\\Sparql.g:165:23: ^( GROUP_CONDITION functionCall )
 3500  
                         {
 3501  0
                         Object root_1 = (Object)adaptor.nil();
 3502  0
                         root_1 = (Object)adaptor.becomeRoot(
 3503  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3504  
                         , root_1);
 3505  
 
 3506  0
                         adaptor.addChild(root_1, stream_functionCall.nextTree());
 3507  
 
 3508  0
                         adaptor.addChild(root_0, root_1);
 3509  
                         }
 3510  
 
 3511  
                     }
 3512  
 
 3513  
 
 3514  0
                     retval.tree = root_0;
 3515  12
 
 3516  12
                     }
 3517  0
                     break;
 3518  
                 case 3 :
 3519  12
                     // com\\googlecode\\sparkleg\\Sparql.g:166:7: '(' expression ( AS var )? ')'
 3520  12
                     {
 3521  48
                     char_literal74=(Token)match(input,209,FOLLOW_209_in_groupCondition1011);  
 3522  60
                     stream_209.add(char_literal74);
 3523  
 
 3524  12
 
 3525  48
                     pushFollow(FOLLOW_expression_in_groupCondition1013);
 3526  48
                     expression75=expression();
 3527  12
 
 3528  60
                     state._fsp--;
 3529  
 
 3530  48
                     stream_expression.add(expression75.getTree());
 3531  4
 
 3532  
                     // com\\googlecode\\sparkleg\\Sparql.g:166:22: ( AS var )?
 3533  48
                     int alt28=2;
 3534  48
                     switch ( input.LA(1) ) {
 3535  
                         case AS:
 3536  12
                             {
 3537  16
                             alt28=1;
 3538  
                             }
 3539  
                             break;
 3540  4
                     }
 3541  4
 
 3542  48
                     switch (alt28) {
 3543  
                         case 1 :
 3544  4
                             // com\\googlecode\\sparkleg\\Sparql.g:166:23: AS var
 3545  4
                             {
 3546  16
                             AS76=(Token)match(input,AS,FOLLOW_AS_in_groupCondition1016);  
 3547  20
                             stream_AS.add(AS76);
 3548  
 
 3549  4
 
 3550  16
                             pushFollow(FOLLOW_var_in_groupCondition1018);
 3551  16
                             var77=var();
 3552  
 
 3553  16
                             state._fsp--;
 3554  
 
 3555  16
                             stream_var.add(var77.getTree());
 3556  
 
 3557  12
                             }
 3558  12
                             break;
 3559  
 
 3560  
                     }
 3561  
 
 3562  
 
 3563  48
                     char_literal78=(Token)match(input,210,FOLLOW_210_in_groupCondition1022);  
 3564  48
                     stream_210.add(char_literal78);
 3565  
 
 3566  
 
 3567  
                     // AST REWRITE
 3568  12
                     // elements: var, expression
 3569  12
                     // token labels: 
 3570  
                     // rule labels: retval
 3571  12
                     // token list labels: 
 3572  
                     // rule list labels: 
 3573  
                     // wildcard labels: 
 3574  48
                     retval.tree = root_0;
 3575  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3576  12
 
 3577  60
                     root_0 = (Object)adaptor.nil();
 3578  
                     // 166:36: -> ^( GROUP_CONDITION expression ( var )? )
 3579  
                     {
 3580  
                         // com\\googlecode\\sparkleg\\Sparql.g:166:39: ^( GROUP_CONDITION expression ( var )? )
 3581  12
                         {
 3582  48
                         Object root_1 = (Object)adaptor.nil();
 3583  48
                         root_1 = (Object)adaptor.becomeRoot(
 3584  12
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3585  
                         , root_1);
 3586  
 
 3587  52
                         adaptor.addChild(root_1, stream_expression.nextTree());
 3588  4
 
 3589  
                         // com\\googlecode\\sparkleg\\Sparql.g:166:68: ( var )?
 3590  48
                         if ( stream_var.hasNext() ) {
 3591  16
                             adaptor.addChild(root_1, stream_var.nextTree());
 3592  4
 
 3593  
                         }
 3594  52
                         stream_var.reset();
 3595  
 
 3596  48
                         adaptor.addChild(root_0, root_1);
 3597  
                         }
 3598  12
 
 3599  12
                     }
 3600  
 
 3601  12
 
 3602  48
                     retval.tree = root_0;
 3603  
 
 3604  
                     }
 3605  48
                     break;
 3606  
                 case 4 :
 3607  12
                     // com\\googlecode\\sparkleg\\Sparql.g:167:7: var
 3608  
                     {
 3609  232
                     pushFollow(FOLLOW_var_in_groupCondition1041);
 3610  244
                     var79=var();
 3611  
 
 3612  232
                     state._fsp--;
 3613  
 
 3614  290
                     stream_var.add(var79.getTree());
 3615  58
 
 3616  
                     // AST REWRITE
 3617  58
                     // elements: var
 3618  
                     // token labels: 
 3619  58
                     // rule labels: retval
 3620  
                     // token list labels: 
 3621  
                     // rule list labels: 
 3622  
                     // wildcard labels: 
 3623  232
                     retval.tree = root_0;
 3624  232
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3625  
 
 3626  232
                     root_0 = (Object)adaptor.nil();
 3627  
                     // 167:11: -> ^( GROUP_CONDITION var )
 3628  58
                     {
 3629  58
                         // com\\googlecode\\sparkleg\\Sparql.g:167:14: ^( GROUP_CONDITION var )
 3630  
                         {
 3631  290
                         Object root_1 = (Object)adaptor.nil();
 3632  232
                         root_1 = (Object)adaptor.becomeRoot(
 3633  
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3634  
                         , root_1);
 3635  
 
 3636  290
                         adaptor.addChild(root_1, stream_var.nextTree());
 3637  58
 
 3638  232
                         adaptor.addChild(root_0, root_1);
 3639  
                         }
 3640  
 
 3641  58
                     }
 3642  
 
 3643  58
 
 3644  232
                     retval.tree = root_0;
 3645  
 
 3646  
                     }
 3647  
                     break;
 3648  
 
 3649  58
             }
 3650  280
             retval.stop = input.LT(-1);
 3651  
 
 3652  
 
 3653  280
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3654  280
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3655  70
 
 3656  
         }
 3657  0
         catch (RecognitionException re) {
 3658  70
             reportError(re);
 3659  70
             recover(input,re);
 3660  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3661  
 
 3662  
         }
 3663  
 
 3664  0
         finally {
 3665  
                 // do for sure before leaving
 3666  280
         }
 3667  280
         return retval;
 3668  
     }
 3669  
     // $ANTLR end "groupCondition"
 3670  
 
 3671  70
 
 3672  70
     public static class havingClause_return extends ParserRuleReturnScope {
 3673  
         Object tree;
 3674  64
         public Object getTree() { return tree; }
 3675  
     };
 3676  
 
 3677  16
 
 3678  
     // $ANTLR start "havingClause"
 3679  16
     // com\\googlecode\\sparkleg\\Sparql.g:170:1: havingClause : HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) ;
 3680  
     public final SparqlParser.havingClause_return havingClause() throws RecognitionException {
 3681  64
         SparqlParser.havingClause_return retval = new SparqlParser.havingClause_return();
 3682  64
         retval.start = input.LT(1);
 3683  
 
 3684  
 
 3685  64
         Object root_0 = null;
 3686  16
 
 3687  80
         Token HAVING80=null;
 3688  64
         SparqlParser.constraint_return constraint81 =null;
 3689  
 
 3690  16
 
 3691  64
         Object HAVING80_tree=null;
 3692  80
         RewriteRuleTokenStream stream_HAVING=new RewriteRuleTokenStream(adaptor,"token HAVING");
 3693  80
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 3694  
         try {
 3695  
             // com\\googlecode\\sparkleg\\Sparql.g:171:5: ( HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) )
 3696  16
             // com\\googlecode\\sparkleg\\Sparql.g:171:7: HAVING ( constraint )+
 3697  16
             {
 3698  80
             HAVING80=(Token)match(input,HAVING,FOLLOW_HAVING_in_havingClause1070);  
 3699  64
             stream_HAVING.add(HAVING80);
 3700  
 
 3701  
 
 3702  
             // com\\googlecode\\sparkleg\\Sparql.g:171:14: ( constraint )+
 3703  80
             int cnt30=0;
 3704  16
             loop30:
 3705  
             do {
 3706  128
                 int alt30=2;
 3707  128
                 switch ( input.LA(1) ) {
 3708  16
                 case ABS:
 3709  
                 case BNODE:
 3710  
                 case BOUND:
 3711  32
                 case CEIL:
 3712  32
                 case COALESCE:
 3713  
                 case CONCAT:
 3714  
                 case CONTAINS:
 3715  
                 case DATATYPE:
 3716  
                 case DAY:
 3717  
                 case ENCODE_FOR_URI:
 3718  
                 case EXISTS:
 3719  
                 case FLOOR:
 3720  
                 case HOURS:
 3721  
                 case IF:
 3722  
                 case IRI:
 3723  
                 case IRI_REF:
 3724  
                 case ISBLANK:
 3725  
                 case ISIRI:
 3726  
                 case ISLITERAL:
 3727  
                 case ISNUMERIC:
 3728  
                 case ISURI:
 3729  
                 case LANG:
 3730  
                 case LANGMATCHES:
 3731  
                 case LCASE:
 3732  
                 case MD5:
 3733  
                 case MINUTES:
 3734  
                 case MONTH:
 3735  
                 case NOT:
 3736  
                 case NOW:
 3737  
                 case PNAME_LN:
 3738  
                 case PNAME_NS:
 3739  
                 case RAND:
 3740  
                 case REGEX:
 3741  
                 case REPLACE:
 3742  
                 case ROUND:
 3743  
                 case SAMETERM:
 3744  
                 case SECONDS:
 3745  
                 case SHA1:
 3746  
                 case SHA256:
 3747  
                 case SHA384:
 3748  
                 case SHA512:
 3749  
                 case STR:
 3750  
                 case STRAFTER:
 3751  
                 case STRBEFORE:
 3752  
                 case STRDT:
 3753  
                 case STRENDS:
 3754  
                 case STRLANG:
 3755  
                 case STRLEN:
 3756  
                 case STRSTARTS:
 3757  
                 case SUBSTR:
 3758  
                 case TIMEZONE:
 3759  
                 case TZ:
 3760  
                 case UCASE:
 3761  
                 case URI:
 3762  
                 case YEAR:
 3763  
                 case 209:
 3764  
                     {
 3765  64
                     alt30=1;
 3766  
                     }
 3767  
                     break;
 3768  
 
 3769  
                 }
 3770  16
 
 3771  128
                 switch (alt30) {
 3772  
                     case 1 :
 3773  
                         // com\\googlecode\\sparkleg\\Sparql.g:171:14: constraint
 3774  
                         {
 3775  64
                         pushFollow(FOLLOW_constraint_in_havingClause1072);
 3776  96
                         constraint81=constraint();
 3777  
 
 3778  64
                         state._fsp--;
 3779  
 
 3780  80
                         stream_constraint.add(constraint81.getTree());
 3781  16
 
 3782  
                         }
 3783  80
                         break;
 3784  
 
 3785  16
                     default :
 3786  64
                         if ( cnt30 >= 1 ) break loop30;
 3787  0
                         EarlyExitException eee =
 3788  16
                             new EarlyExitException(30, input);
 3789  0
                         throw eee;
 3790  
                 }
 3791  80
                 cnt30++;
 3792  64
             } while (true);
 3793  
 
 3794  
 
 3795  
             // AST REWRITE
 3796  16
             // elements: HAVING, constraint
 3797  16
             // token labels: 
 3798  
             // rule labels: retval
 3799  
             // token list labels: 
 3800  
             // rule list labels: 
 3801  
             // wildcard labels: 
 3802  64
             retval.tree = root_0;
 3803  64
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3804  
 
 3805  64
             root_0 = (Object)adaptor.nil();
 3806  
             // 171:26: -> ^( HAVING ( constraint )+ )
 3807  16
             {
 3808  16
                 // com\\googlecode\\sparkleg\\Sparql.g:171:29: ^( HAVING ( constraint )+ )
 3809  
                 {
 3810  80
                 Object root_1 = (Object)adaptor.nil();
 3811  64
                 root_1 = (Object)adaptor.becomeRoot(
 3812  
                 stream_HAVING.nextNode()
 3813  
                 , root_1);
 3814  
 
 3815  80
                 if ( !(stream_constraint.hasNext()) ) {
 3816  16
                     throw new RewriteEarlyExitException();
 3817  
                 }
 3818  128
                 while ( stream_constraint.hasNext() ) {
 3819  64
                     adaptor.addChild(root_1, stream_constraint.nextTree());
 3820  16
 
 3821  
                 }
 3822  64
                 stream_constraint.reset();
 3823  32
 
 3824  80
                 adaptor.addChild(root_0, root_1);
 3825  
                 }
 3826  
 
 3827  16
             }
 3828  
 
 3829  16
 
 3830  64
             retval.tree = root_0;
 3831  
 
 3832  
             }
 3833  
 
 3834  64
             retval.stop = input.LT(-1);
 3835  16
 
 3836  
 
 3837  64
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3838  64
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3839  16
 
 3840  
         }
 3841  0
         catch (RecognitionException re) {
 3842  16
             reportError(re);
 3843  16
             recover(input,re);
 3844  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3845  
 
 3846  
         }
 3847  
 
 3848  0
         finally {
 3849  
                 // do for sure before leaving
 3850  64
         }
 3851  64
         return retval;
 3852  
     }
 3853  
     // $ANTLR end "havingClause"
 3854  
 
 3855  16
 
 3856  16
     public static class orderClause_return extends ParserRuleReturnScope {
 3857  
         Object tree;
 3858  536
         public Object getTree() { return tree; }
 3859  
     };
 3860  
 
 3861  134
 
 3862  
     // $ANTLR start "orderClause"
 3863  134
     // com\\googlecode\\sparkleg\\Sparql.g:174:1: orderClause : ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) ;
 3864  
     public final SparqlParser.orderClause_return orderClause() throws RecognitionException {
 3865  536
         SparqlParser.orderClause_return retval = new SparqlParser.orderClause_return();
 3866  536
         retval.start = input.LT(1);
 3867  
 
 3868  
 
 3869  536
         Object root_0 = null;
 3870  134
 
 3871  670
         Token ORDER82=null;
 3872  536
         Token BY83=null;
 3873  536
         SparqlParser.orderCondition_return orderCondition84 =null;
 3874  134
 
 3875  
 
 3876  670
         Object ORDER82_tree=null;
 3877  670
         Object BY83_tree=null;
 3878  670
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3879  536
         RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
 3880  536
         RewriteRuleSubtreeStream stream_orderCondition=new RewriteRuleSubtreeStream(adaptor,"rule orderCondition");
 3881  134
         try {
 3882  134
             // com\\googlecode\\sparkleg\\Sparql.g:175:5: ( ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) )
 3883  134
             // com\\googlecode\\sparkleg\\Sparql.g:175:7: ORDER BY ( orderCondition )+
 3884  134
             {
 3885  670
             ORDER82=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderClause1104);  
 3886  536
             stream_ORDER.add(ORDER82);
 3887  
 
 3888  
 
 3889  536
             BY83=(Token)match(input,BY,FOLLOW_BY_in_orderClause1106);  
 3890  670
             stream_BY.add(BY83);
 3891  134
 
 3892  
 
 3893  
             // com\\googlecode\\sparkleg\\Sparql.g:175:16: ( orderCondition )+
 3894  670
             int cnt31=0;
 3895  134
             loop31:
 3896  
             do {
 3897  1264
                 int alt31=2;
 3898  1264
                 switch ( input.LA(1) ) {
 3899  134
                 case ABS:
 3900  
                 case ASC:
 3901  
                 case BNODE:
 3902  316
                 case BOUND:
 3903  316
                 case CEIL:
 3904  
                 case COALESCE:
 3905  
                 case CONCAT:
 3906  
                 case CONTAINS:
 3907  
                 case DATATYPE:
 3908  
                 case DAY:
 3909  
                 case DESC:
 3910  
                 case ENCODE_FOR_URI:
 3911  
                 case EXISTS:
 3912  
                 case FLOOR:
 3913  
                 case HOURS:
 3914  
                 case IF:
 3915  
                 case IRI:
 3916  
                 case IRI_REF:
 3917  
                 case ISBLANK:
 3918  
                 case ISIRI:
 3919  
                 case ISLITERAL:
 3920  
                 case ISNUMERIC:
 3921  
                 case ISURI:
 3922  
                 case LANG:
 3923  
                 case LANGMATCHES:
 3924  
                 case LCASE:
 3925  
                 case MD5:
 3926  
                 case MINUTES:
 3927  
                 case MONTH:
 3928  
                 case NOT:
 3929  
                 case NOW:
 3930  
                 case PNAME_LN:
 3931  
                 case PNAME_NS:
 3932  
                 case RAND:
 3933  
                 case REGEX:
 3934  
                 case REPLACE:
 3935  
                 case ROUND:
 3936  
                 case SAMETERM:
 3937  
                 case SECONDS:
 3938  
                 case SHA1:
 3939  
                 case SHA256:
 3940  
                 case SHA384:
 3941  
                 case SHA512:
 3942  
                 case STR:
 3943  
                 case STRAFTER:
 3944  
                 case STRBEFORE:
 3945  
                 case STRDT:
 3946  
                 case STRENDS:
 3947  
                 case STRLANG:
 3948  
                 case STRLEN:
 3949  
                 case STRSTARTS:
 3950  
                 case SUBSTR:
 3951  
                 case TIMEZONE:
 3952  
                 case TZ:
 3953  
                 case UCASE:
 3954  
                 case URI:
 3955  
                 case VAR1:
 3956  
                 case VAR2:
 3957  
                 case YEAR:
 3958  
                 case 209:
 3959  
                     {
 3960  728
                     alt31=1;
 3961  
                     }
 3962  
                     break;
 3963  
 
 3964  
                 }
 3965  182
 
 3966  1264
                 switch (alt31) {
 3967  
                     case 1 :
 3968  
                         // com\\googlecode\\sparkleg\\Sparql.g:175:16: orderCondition
 3969  
                         {
 3970  728
                         pushFollow(FOLLOW_orderCondition_in_orderClause1108);
 3971  1044
                         orderCondition84=orderCondition();
 3972  
 
 3973  728
                         state._fsp--;
 3974  
 
 3975  910
                         stream_orderCondition.add(orderCondition84.getTree());
 3976  182
 
 3977  
                         }
 3978  910
                         break;
 3979  
 
 3980  182
                     default :
 3981  536
                         if ( cnt31 >= 1 ) break loop31;
 3982  0
                         EarlyExitException eee =
 3983  182
                             new EarlyExitException(31, input);
 3984  0
                         throw eee;
 3985  
                 }
 3986  862
                 cnt31++;
 3987  728
             } while (true);
 3988  
 
 3989  
 
 3990  
             // AST REWRITE
 3991  182
             // elements: orderCondition
 3992  182
             // token labels: 
 3993  
             // rule labels: retval
 3994  
             // token list labels: 
 3995  
             // rule list labels: 
 3996  
             // wildcard labels: 
 3997  536
             retval.tree = root_0;
 3998  536
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3999  
 
 4000  536
             root_0 = (Object)adaptor.nil();
 4001  
             // 175:32: -> ^( ORDER_BY ( orderCondition )+ )
 4002  134
             {
 4003  134
                 // com\\googlecode\\sparkleg\\Sparql.g:175:35: ^( ORDER_BY ( orderCondition )+ )
 4004  
                 {
 4005  670
                 Object root_1 = (Object)adaptor.nil();
 4006  536
                 root_1 = (Object)adaptor.becomeRoot(
 4007  
                 (Object)adaptor.create(ORDER_BY, "ORDER_BY")
 4008  
                 , root_1);
 4009  
 
 4010  670
                 if ( !(stream_orderCondition.hasNext()) ) {
 4011  134
                     throw new RewriteEarlyExitException();
 4012  
                 }
 4013  1264
                 while ( stream_orderCondition.hasNext() ) {
 4014  728
                     adaptor.addChild(root_1, stream_orderCondition.nextTree());
 4015  134
 
 4016  
                 }
 4017  536
                 stream_orderCondition.reset();
 4018  316
 
 4019  718
                 adaptor.addChild(root_0, root_1);
 4020  
                 }
 4021  
 
 4022  134
             }
 4023  
 
 4024  134
 
 4025  536
             retval.tree = root_0;
 4026  
 
 4027  
             }
 4028  
 
 4029  536
             retval.stop = input.LT(-1);
 4030  134
 
 4031  
 
 4032  536
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4033  536
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4034  134
 
 4035  
         }
 4036  0
         catch (RecognitionException re) {
 4037  134
             reportError(re);
 4038  134
             recover(input,re);
 4039  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4040  
 
 4041  
         }
 4042  
 
 4043  0
         finally {
 4044  
                 // do for sure before leaving
 4045  536
         }
 4046  536
         return retval;
 4047  
     }
 4048  
     // $ANTLR end "orderClause"
 4049  
 
 4050  134
 
 4051  134
     public static class orderCondition_return extends ParserRuleReturnScope {
 4052  
         Object tree;
 4053  728
         public Object getTree() { return tree; }
 4054  
     };
 4055  
 
 4056  182
 
 4057  
     // $ANTLR start "orderCondition"
 4058  182
     // com\\googlecode\\sparkleg\\Sparql.g:178:1: orderCondition : ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) );
 4059  
     public final SparqlParser.orderCondition_return orderCondition() throws RecognitionException {
 4060  728
         SparqlParser.orderCondition_return retval = new SparqlParser.orderCondition_return();
 4061  728
         retval.start = input.LT(1);
 4062  
 
 4063  
 
 4064  728
         Object root_0 = null;
 4065  182
 
 4066  910
         Token ASC85=null;
 4067  728
         Token DESC87=null;
 4068  728
         SparqlParser.brackettedExpression_return brackettedExpression86 =null;
 4069  182
 
 4070  728
         SparqlParser.brackettedExpression_return brackettedExpression88 =null;
 4071  182
 
 4072  910
         SparqlParser.constraint_return constraint89 =null;
 4073  182
 
 4074  728
         SparqlParser.var_return var90 =null;
 4075  182
 
 4076  
 
 4077  910
         Object ASC85_tree=null;
 4078  728
         Object DESC87_tree=null;
 4079  910
         RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
 4080  728
         RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
 4081  728
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4082  910
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 4083  910
         RewriteRuleSubtreeStream stream_brackettedExpression=new RewriteRuleSubtreeStream(adaptor,"rule brackettedExpression");
 4084  182
         try {
 4085  182
             // com\\googlecode\\sparkleg\\Sparql.g:179:5: ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) )
 4086  910
             int alt32=4;
 4087  910
             switch ( input.LA(1) ) {
 4088  182
             case ASC:
 4089  
                 {
 4090  40
                 alt32=1;
 4091  182
                 }
 4092  222
                 break;
 4093  
             case DESC:
 4094  
                 {
 4095  130
                 alt32=2;
 4096  
                 }
 4097  130
                 break;
 4098  
             case ABS:
 4099  
             case BNODE:
 4100  30
             case BOUND:
 4101  
             case CEIL:
 4102  30
             case COALESCE:
 4103  
             case CONCAT:
 4104  
             case CONTAINS:
 4105  
             case DATATYPE:
 4106  
             case DAY:
 4107  
             case ENCODE_FOR_URI:
 4108  
             case EXISTS:
 4109  
             case FLOOR:
 4110  
             case HOURS:
 4111  
             case IF:
 4112  
             case IRI:
 4113  
             case IRI_REF:
 4114  
             case ISBLANK:
 4115  
             case ISIRI:
 4116  
             case ISLITERAL:
 4117  
             case ISNUMERIC:
 4118  
             case ISURI:
 4119  
             case LANG:
 4120  
             case LANGMATCHES:
 4121  
             case LCASE:
 4122  
             case MD5:
 4123  
             case MINUTES:
 4124  
             case MONTH:
 4125  
             case NOT:
 4126  
             case NOW:
 4127  
             case PNAME_LN:
 4128  
             case PNAME_NS:
 4129  
             case RAND:
 4130  
             case REGEX:
 4131  
             case REPLACE:
 4132  
             case ROUND:
 4133  
             case SAMETERM:
 4134  
             case SECONDS:
 4135  
             case SHA1:
 4136  
             case SHA256:
 4137  
             case SHA384:
 4138  
             case SHA512:
 4139  
             case STR:
 4140  
             case STRAFTER:
 4141  
             case STRBEFORE:
 4142  
             case STRDT:
 4143  
             case STRENDS:
 4144  
             case STRLANG:
 4145  
             case STRLEN:
 4146  
             case STRSTARTS:
 4147  
             case SUBSTR:
 4148  
             case TIMEZONE:
 4149  
             case TZ:
 4150  
             case UCASE:
 4151  
             case URI:
 4152  
             case YEAR:
 4153  
             case 209:
 4154  
                 {
 4155  48
                 alt32=3;
 4156  
                 }
 4157  48
                 break;
 4158  
             case VAR1:
 4159  
             case VAR2:
 4160  12
                 {
 4161  520
                 alt32=4;
 4162  12
                 }
 4163  520
                 break;
 4164  
             default:
 4165  0
                 NoViableAltException nvae =
 4166  130
                     new NoViableAltException("", 32, 0, input);
 4167  
 
 4168  130
                 throw nvae;
 4169  
 
 4170  
             }
 4171  
 
 4172  728
             switch (alt32) {
 4173  
                 case 1 :
 4174  
                     // com\\googlecode\\sparkleg\\Sparql.g:179:7: ASC brackettedExpression
 4175  
                     {
 4176  40
                     ASC85=(Token)match(input,ASC,FOLLOW_ASC_in_orderCondition1135);  
 4177  222
                     stream_ASC.add(ASC85);
 4178  
 
 4179  
 
 4180  40
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1137);
 4181  50
                     brackettedExpression86=brackettedExpression();
 4182  10
 
 4183  40
                     state._fsp--;
 4184  
 
 4185  50
                     stream_brackettedExpression.add(brackettedExpression86.getTree());
 4186  10
 
 4187  
                     // AST REWRITE
 4188  10
                     // elements: brackettedExpression, ASC
 4189  
                     // token labels: 
 4190  10
                     // rule labels: retval
 4191  
                     // token list labels: 
 4192  
                     // rule list labels: 
 4193  
                     // wildcard labels: 
 4194  40
                     retval.tree = root_0;
 4195  40
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4196  
 
 4197  40
                     root_0 = (Object)adaptor.nil();
 4198  
                     // 179:32: -> ^( ORDER_CONDITION ASC brackettedExpression )
 4199  10
                     {
 4200  10
                         // com\\googlecode\\sparkleg\\Sparql.g:179:35: ^( ORDER_CONDITION ASC brackettedExpression )
 4201  
                         {
 4202  50
                         Object root_1 = (Object)adaptor.nil();
 4203  40
                         root_1 = (Object)adaptor.becomeRoot(
 4204  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4205  
                         , root_1);
 4206  
 
 4207  50
                         adaptor.addChild(root_1, 
 4208  10
                         stream_ASC.nextNode()
 4209  
                         );
 4210  
 
 4211  40
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4212  10
 
 4213  40
                         adaptor.addChild(root_0, root_1);
 4214  
                         }
 4215  
 
 4216  10
                     }
 4217  
 
 4218  10
 
 4219  40
                     retval.tree = root_0;
 4220  
 
 4221  
                     }
 4222  40
                     break;
 4223  
                 case 2 :
 4224  10
                     // com\\googlecode\\sparkleg\\Sparql.g:180:7: DESC brackettedExpression
 4225  
                     {
 4226  120
                     DESC87=(Token)match(input,DESC,FOLLOW_DESC_in_orderCondition1155);  
 4227  130
                     stream_DESC.add(DESC87);
 4228  
 
 4229  
 
 4230  120
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1157);
 4231  150
                     brackettedExpression88=brackettedExpression();
 4232  30
 
 4233  120
                     state._fsp--;
 4234  
 
 4235  150
                     stream_brackettedExpression.add(brackettedExpression88.getTree());
 4236  30
 
 4237  
                     // AST REWRITE
 4238  30
                     // elements: brackettedExpression, DESC
 4239  
                     // token labels: 
 4240  30
                     // rule labels: retval
 4241  
                     // token list labels: 
 4242  
                     // rule list labels: 
 4243  
                     // wildcard labels: 
 4244  120
                     retval.tree = root_0;
 4245  120
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4246  
 
 4247  120
                     root_0 = (Object)adaptor.nil();
 4248  
                     // 180:33: -> ^( ORDER_CONDITION DESC brackettedExpression )
 4249  30
                     {
 4250  30
                         // com\\googlecode\\sparkleg\\Sparql.g:180:36: ^( ORDER_CONDITION DESC brackettedExpression )
 4251  
                         {
 4252  150
                         Object root_1 = (Object)adaptor.nil();
 4253  120
                         root_1 = (Object)adaptor.becomeRoot(
 4254  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4255  
                         , root_1);
 4256  
 
 4257  150
                         adaptor.addChild(root_1, 
 4258  30
                         stream_DESC.nextNode()
 4259  
                         );
 4260  
 
 4261  120
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4262  30
 
 4263  120
                         adaptor.addChild(root_0, root_1);
 4264  
                         }
 4265  
 
 4266  30
                     }
 4267  
 
 4268  30
 
 4269  120
                     retval.tree = root_0;
 4270  
 
 4271  
                     }
 4272  120
                     break;
 4273  
                 case 3 :
 4274  30
                     // com\\googlecode\\sparkleg\\Sparql.g:181:7: constraint
 4275  
                     {
 4276  48
                     pushFollow(FOLLOW_constraint_in_orderCondition1175);
 4277  78
                     constraint89=constraint();
 4278  
 
 4279  48
                     state._fsp--;
 4280  
 
 4281  60
                     stream_constraint.add(constraint89.getTree());
 4282  12
 
 4283  
                     // AST REWRITE
 4284  12
                     // elements: constraint
 4285  
                     // token labels: 
 4286  12
                     // rule labels: retval
 4287  
                     // token list labels: 
 4288  
                     // rule list labels: 
 4289  
                     // wildcard labels: 
 4290  48
                     retval.tree = root_0;
 4291  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4292  
 
 4293  48
                     root_0 = (Object)adaptor.nil();
 4294  
                     // 181:18: -> ^( ORDER_CONDITION constraint )
 4295  12
                     {
 4296  12
                         // com\\googlecode\\sparkleg\\Sparql.g:181:21: ^( ORDER_CONDITION constraint )
 4297  
                         {
 4298  60
                         Object root_1 = (Object)adaptor.nil();
 4299  48
                         root_1 = (Object)adaptor.becomeRoot(
 4300  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4301  
                         , root_1);
 4302  
 
 4303  60
                         adaptor.addChild(root_1, stream_constraint.nextTree());
 4304  12
 
 4305  48
                         adaptor.addChild(root_0, root_1);
 4306  
                         }
 4307  
 
 4308  12
                     }
 4309  
 
 4310  12
 
 4311  48
                     retval.tree = root_0;
 4312  
 
 4313  
                     }
 4314  48
                     break;
 4315  
                 case 4 :
 4316  12
                     // com\\googlecode\\sparkleg\\Sparql.g:182:7: var
 4317  
                     {
 4318  520
                     pushFollow(FOLLOW_var_in_orderCondition1191);
 4319  532
                     var90=var();
 4320  
 
 4321  520
                     state._fsp--;
 4322  
 
 4323  650
                     stream_var.add(var90.getTree());
 4324  130
 
 4325  
                     // AST REWRITE
 4326  130
                     // elements: var
 4327  
                     // token labels: 
 4328  130
                     // rule labels: retval
 4329  
                     // token list labels: 
 4330  
                     // rule list labels: 
 4331  
                     // wildcard labels: 
 4332  520
                     retval.tree = root_0;
 4333  520
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4334  
 
 4335  520
                     root_0 = (Object)adaptor.nil();
 4336  
                     // 182:11: -> ^( ORDER_CONDITION var )
 4337  130
                     {
 4338  130
                         // com\\googlecode\\sparkleg\\Sparql.g:182:14: ^( ORDER_CONDITION var )
 4339  
                         {
 4340  650
                         Object root_1 = (Object)adaptor.nil();
 4341  520
                         root_1 = (Object)adaptor.becomeRoot(
 4342  
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4343  
                         , root_1);
 4344  
 
 4345  650
                         adaptor.addChild(root_1, stream_var.nextTree());
 4346  130
 
 4347  520
                         adaptor.addChild(root_0, root_1);
 4348  
                         }
 4349  
 
 4350  130
                     }
 4351  
 
 4352  130
 
 4353  520
                     retval.tree = root_0;
 4354  
 
 4355  
                     }
 4356  
                     break;
 4357  
 
 4358  130
             }
 4359  728
             retval.stop = input.LT(-1);
 4360  
 
 4361  
 
 4362  728
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4363  728
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4364  182
 
 4365  
         }
 4366  0
         catch (RecognitionException re) {
 4367  182
             reportError(re);
 4368  182
             recover(input,re);
 4369  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4370  
 
 4371  
         }
 4372  
 
 4373  0
         finally {
 4374  
                 // do for sure before leaving
 4375  728
         }
 4376  728
         return retval;
 4377  
     }
 4378  
     // $ANTLR end "orderCondition"
 4379  
 
 4380  182
 
 4381  182
     public static class limitOffsetClauses_return extends ParserRuleReturnScope {
 4382  
         Object tree;
 4383  232
         public Object getTree() { return tree; }
 4384  
     };
 4385  
 
 4386  58
 
 4387  
     // $ANTLR start "limitOffsetClauses"
 4388  58
     // com\\googlecode\\sparkleg\\Sparql.g:185:1: limitOffsetClauses : ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* );
 4389  
     public final SparqlParser.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4390  232
         SparqlParser.limitOffsetClauses_return retval = new SparqlParser.limitOffsetClauses_return();
 4391  232
         retval.start = input.LT(1);
 4392  
 
 4393  
 
 4394  232
         Object root_0 = null;
 4395  58
 
 4396  290
         SparqlParser.limitClause_return limitClause91 =null;
 4397  
 
 4398  232
         SparqlParser.offsetClause_return offsetClause92 =null;
 4399  58
 
 4400  232
         SparqlParser.offsetClause_return offsetClause93 =null;
 4401  58
 
 4402  232
         SparqlParser.limitClause_return limitClause94 =null;
 4403  58
 
 4404  
 
 4405  290
         RewriteRuleSubtreeStream stream_offsetClause=new RewriteRuleSubtreeStream(adaptor,"rule offsetClause");
 4406  232
         RewriteRuleSubtreeStream stream_limitClause=new RewriteRuleSubtreeStream(adaptor,"rule limitClause");
 4407  58
         try {
 4408  
             // com\\googlecode\\sparkleg\\Sparql.g:186:5: ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* )
 4409  232
             int alt35=2;
 4410  290
             switch ( input.LA(1) ) {
 4411  58
             case LIMIT:
 4412  
                 {
 4413  167
                 alt35=1;
 4414  58
                 }
 4415  225
                 break;
 4416  
             case OFFSET:
 4417  
                 {
 4418  103
                 alt35=2;
 4419  
                 }
 4420  103
                 break;
 4421  
             default:
 4422  0
                 NoViableAltException nvae =
 4423  20
                     new NoViableAltException("", 35, 0, input);
 4424  
 
 4425  20
                 throw nvae;
 4426  
 
 4427  
             }
 4428  
 
 4429  232
             switch (alt35) {
 4430  
                 case 1 :
 4431  
                     // com\\googlecode\\sparkleg\\Sparql.g:186:7: limitClause ( offsetClause )?
 4432  
                     {
 4433  167
                     pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1221);
 4434  225
                     limitClause91=limitClause();
 4435  
 
 4436  167
                     state._fsp--;
 4437  
 
 4438  205
                     stream_limitClause.add(limitClause91.getTree());
 4439  38
 
 4440  
                     // com\\googlecode\\sparkleg\\Sparql.g:186:19: ( offsetClause )?
 4441  205
                     int alt33=2;
 4442  167
                     switch ( input.LA(1) ) {
 4443  38
                         case OFFSET:
 4444  
                             {
 4445  63
                             alt33=1;
 4446  38
                             }
 4447  38
                             break;
 4448  
                     }
 4449  
 
 4450  179
                     switch (alt33) {
 4451  
                         case 1 :
 4452  
                             // com\\googlecode\\sparkleg\\Sparql.g:186:19: offsetClause
 4453  
                             {
 4454  63
                             pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1223);
 4455  101
                             offsetClause92=offsetClause();
 4456  
 
 4457  63
                             state._fsp--;
 4458  
 
 4459  75
                             stream_offsetClause.add(offsetClause92.getTree());
 4460  12
 
 4461  
                             }
 4462  12
                             break;
 4463  
 
 4464  12
                     }
 4465  
 
 4466  
 
 4467  
                     // AST REWRITE
 4468  
                     // elements: limitClause, offsetClause
 4469  
                     // token labels: 
 4470  
                     // rule labels: retval
 4471  
                     // token list labels: 
 4472  
                     // rule list labels: 
 4473  
                     // wildcard labels: 
 4474  167
                     retval.tree = root_0;
 4475  167
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4476  
 
 4477  167
                     root_0 = (Object)adaptor.nil();
 4478  
                     // 186:33: -> limitClause ( offsetClause )*
 4479  38
                     {
 4480  205
                         adaptor.addChild(root_0, stream_limitClause.nextTree());
 4481  
 
 4482  38
                         // com\\googlecode\\sparkleg\\Sparql.g:186:48: ( offsetClause )*
 4483  230
                         while ( stream_offsetClause.hasNext() ) {
 4484  63
                             adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4485  38
 
 4486  
                         }
 4487  167
                         stream_offsetClause.reset();
 4488  50
 
 4489  12
                     }
 4490  
 
 4491  
 
 4492  205
                     retval.tree = root_0;
 4493  
 
 4494  
                     }
 4495  167
                     break;
 4496  
                 case 2 :
 4497  38
                     // com\\googlecode\\sparkleg\\Sparql.g:187:7: offsetClause ( limitClause )?
 4498  
                     {
 4499  65
                     pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1239);
 4500  103
                     offsetClause93=offsetClause();
 4501  
 
 4502  65
                     state._fsp--;
 4503  
 
 4504  85
                     stream_offsetClause.add(offsetClause93.getTree());
 4505  20
 
 4506  
                     // com\\googlecode\\sparkleg\\Sparql.g:187:20: ( limitClause )?
 4507  85
                     int alt34=2;
 4508  65
                     switch ( input.LA(1) ) {
 4509  20
                         case LIMIT:
 4510  
                             {
 4511  25
                             alt34=1;
 4512  20
                             }
 4513  20
                             break;
 4514  
                     }
 4515  
 
 4516  75
                     switch (alt34) {
 4517  
                         case 1 :
 4518  
                             // com\\googlecode\\sparkleg\\Sparql.g:187:20: limitClause
 4519  
                             {
 4520  25
                             pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1241);
 4521  45
                             limitClause94=limitClause();
 4522  
 
 4523  25
                             state._fsp--;
 4524  
 
 4525  35
                             stream_limitClause.add(limitClause94.getTree());
 4526  10
 
 4527  
                             }
 4528  10
                             break;
 4529  
 
 4530  10
                     }
 4531  
 
 4532  
 
 4533  
                     // AST REWRITE
 4534  
                     // elements: offsetClause, limitClause
 4535  
                     // token labels: 
 4536  
                     // rule labels: retval
 4537  
                     // token list labels: 
 4538  
                     // rule list labels: 
 4539  
                     // wildcard labels: 
 4540  65
                     retval.tree = root_0;
 4541  65
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4542  
 
 4543  65
                     root_0 = (Object)adaptor.nil();
 4544  
                     // 187:33: -> offsetClause ( limitClause )*
 4545  20
                     {
 4546  85
                         adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4547  
 
 4548  20
                         // com\\googlecode\\sparkleg\\Sparql.g:187:49: ( limitClause )*
 4549  90
                         while ( stream_limitClause.hasNext() ) {
 4550  25
                             adaptor.addChild(root_0, stream_limitClause.nextTree());
 4551  20
 
 4552  
                         }
 4553  65
                         stream_limitClause.reset();
 4554  30
 
 4555  10
                     }
 4556  
 
 4557  
 
 4558  85
                     retval.tree = root_0;
 4559  
 
 4560  
                     }
 4561  
                     break;
 4562  
 
 4563  20
             }
 4564  232
             retval.stop = input.LT(-1);
 4565  
 
 4566  
 
 4567  232
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4568  232
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4569  58
 
 4570  
         }
 4571  0
         catch (RecognitionException re) {
 4572  58
             reportError(re);
 4573  58
             recover(input,re);
 4574  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4575  
 
 4576  
         }
 4577  
 
 4578  0
         finally {
 4579  
                 // do for sure before leaving
 4580  232
         }
 4581  232
         return retval;
 4582  
     }
 4583  
     // $ANTLR end "limitOffsetClauses"
 4584  
 
 4585  58
 
 4586  192
     public static class limitClause_return extends ParserRuleReturnScope {
 4587  
         Object tree;
 4588  192
         public Object getTree() { return tree; }
 4589  
     };
 4590  
 
 4591  48
 
 4592  
     // $ANTLR start "limitClause"
 4593  48
     // com\\googlecode\\sparkleg\\Sparql.g:190:1: limitClause : LIMIT INTEGER -> ^( LIMIT INTEGER ) ;
 4594  
     public final SparqlParser.limitClause_return limitClause() throws RecognitionException {
 4595  192
         SparqlParser.limitClause_return retval = new SparqlParser.limitClause_return();
 4596  192
         retval.start = input.LT(1);
 4597  
 
 4598  
 
 4599  192
         Object root_0 = null;
 4600  48
 
 4601  240
         Token LIMIT95=null;
 4602  192
         Token INTEGER96=null;
 4603  
 
 4604  240
         Object LIMIT95_tree=null;
 4605  192
         Object INTEGER96_tree=null;
 4606  240
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4607  240
         RewriteRuleTokenStream stream_LIMIT=new RewriteRuleTokenStream(adaptor,"token LIMIT");
 4608  
 
 4609  48
         try {
 4610  48
             // com\\googlecode\\sparkleg\\Sparql.g:191:5: ( LIMIT INTEGER -> ^( LIMIT INTEGER ) )
 4611  48
             // com\\googlecode\\sparkleg\\Sparql.g:191:7: LIMIT INTEGER
 4612  48
             {
 4613  192
             LIMIT95=(Token)match(input,LIMIT,FOLLOW_LIMIT_in_limitClause1266);  
 4614  192
             stream_LIMIT.add(LIMIT95);
 4615  
 
 4616  
 
 4617  192
             INTEGER96=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_limitClause1268);  
 4618  240
             stream_INTEGER.add(INTEGER96);
 4619  48
 
 4620  
 
 4621  
             // AST REWRITE
 4622  48
             // elements: LIMIT, INTEGER
 4623  48
             // token labels: 
 4624  
             // rule labels: retval
 4625  
             // token list labels: 
 4626  
             // rule list labels: 
 4627  
             // wildcard labels: 
 4628  192
             retval.tree = root_0;
 4629  192
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4630  
 
 4631  192
             root_0 = (Object)adaptor.nil();
 4632  
             // 191:21: -> ^( LIMIT INTEGER )
 4633  48
             {
 4634  48
                 // com\\googlecode\\sparkleg\\Sparql.g:191:24: ^( LIMIT INTEGER )
 4635  
                 {
 4636  240
                 Object root_1 = (Object)adaptor.nil();
 4637  192
                 root_1 = (Object)adaptor.becomeRoot(
 4638  
                 stream_LIMIT.nextNode()
 4639  
                 , root_1);
 4640  
 
 4641  240
                 adaptor.addChild(root_1, 
 4642  48
                 stream_INTEGER.nextNode()
 4643  
                 );
 4644  
 
 4645  192
                 adaptor.addChild(root_0, root_1);
 4646  48
                 }
 4647  
 
 4648  
             }
 4649  
 
 4650  48
 
 4651  192
             retval.tree = root_0;
 4652  
 
 4653  
             }
 4654  
 
 4655  192
             retval.stop = input.LT(-1);
 4656  48
 
 4657  
 
 4658  192
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4659  192
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4660  48
 
 4661  
         }
 4662  0
         catch (RecognitionException re) {
 4663  48
             reportError(re);
 4664  48
             recover(input,re);
 4665  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4666  
 
 4667  
         }
 4668  
 
 4669  0
         finally {
 4670  
                 // do for sure before leaving
 4671  192
         }
 4672  192
         return retval;
 4673  
     }
 4674  
     // $ANTLR end "limitClause"
 4675  
 
 4676  48
 
 4677  48
     public static class offsetClause_return extends ParserRuleReturnScope {
 4678  
         Object tree;
 4679  128
         public Object getTree() { return tree; }
 4680  
     };
 4681  
 
 4682  32
 
 4683  
     // $ANTLR start "offsetClause"
 4684  32
     // com\\googlecode\\sparkleg\\Sparql.g:194:1: offsetClause : OFFSET INTEGER -> ^( OFFSET INTEGER ) ;
 4685  
     public final SparqlParser.offsetClause_return offsetClause() throws RecognitionException {
 4686  128
         SparqlParser.offsetClause_return retval = new SparqlParser.offsetClause_return();
 4687  128
         retval.start = input.LT(1);
 4688  
 
 4689  
 
 4690  128
         Object root_0 = null;
 4691  32
 
 4692  160
         Token OFFSET97=null;
 4693  128
         Token INTEGER98=null;
 4694  
 
 4695  160
         Object OFFSET97_tree=null;
 4696  128
         Object INTEGER98_tree=null;
 4697  160
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4698  160
         RewriteRuleTokenStream stream_OFFSET=new RewriteRuleTokenStream(adaptor,"token OFFSET");
 4699  
 
 4700  32
         try {
 4701  32
             // com\\googlecode\\sparkleg\\Sparql.g:195:5: ( OFFSET INTEGER -> ^( OFFSET INTEGER ) )
 4702  32
             // com\\googlecode\\sparkleg\\Sparql.g:195:7: OFFSET INTEGER
 4703  32
             {
 4704  128
             OFFSET97=(Token)match(input,OFFSET,FOLLOW_OFFSET_in_offsetClause1293);  
 4705  128
             stream_OFFSET.add(OFFSET97);
 4706  
 
 4707  
 
 4708  128
             INTEGER98=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_offsetClause1295);  
 4709  160
             stream_INTEGER.add(INTEGER98);
 4710  32
 
 4711  
 
 4712  
             // AST REWRITE
 4713  32
             // elements: INTEGER, OFFSET
 4714  32
             // token labels: 
 4715  
             // rule labels: retval
 4716  
             // token list labels: 
 4717  
             // rule list labels: 
 4718  
             // wildcard labels: 
 4719  128
             retval.tree = root_0;
 4720  128
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4721  
 
 4722  128
             root_0 = (Object)adaptor.nil();
 4723  
             // 195:22: -> ^( OFFSET INTEGER )
 4724  32
             {
 4725  32
                 // com\\googlecode\\sparkleg\\Sparql.g:195:25: ^( OFFSET INTEGER )
 4726  
                 {
 4727  160
                 Object root_1 = (Object)adaptor.nil();
 4728  128
                 root_1 = (Object)adaptor.becomeRoot(
 4729  
                 stream_OFFSET.nextNode()
 4730  
                 , root_1);
 4731  
 
 4732  160
                 adaptor.addChild(root_1, 
 4733  32
                 stream_INTEGER.nextNode()
 4734  
                 );
 4735  
 
 4736  128
                 adaptor.addChild(root_0, root_1);
 4737  32
                 }
 4738  
 
 4739  
             }
 4740  
 
 4741  32
 
 4742  128
             retval.tree = root_0;
 4743  
 
 4744  
             }
 4745  
 
 4746  128
             retval.stop = input.LT(-1);
 4747  32
 
 4748  
 
 4749  128
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4750  128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4751  32
 
 4752  
         }
 4753  0
         catch (RecognitionException re) {
 4754  32
             reportError(re);
 4755  32
             recover(input,re);
 4756  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4757  
 
 4758  
         }
 4759  
 
 4760  0
         finally {
 4761  
                 // do for sure before leaving
 4762  128
         }
 4763  128
         return retval;
 4764  
     }
 4765  
     // $ANTLR end "offsetClause"
 4766  
 
 4767  32
 
 4768  32
     public static class bindingsClause_return extends ParserRuleReturnScope {
 4769  
         Object tree;
 4770  7144
         public Object getTree() { return tree; }
 4771  
     };
 4772  
 
 4773  1834
 
 4774  
     // $ANTLR start "bindingsClause"
 4775  1834
     // com\\googlecode\\sparkleg\\Sparql.g:198:1: bindingsClause : ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? ;
 4776  
     public final SparqlParser.bindingsClause_return bindingsClause() throws RecognitionException {
 4777  7144
         SparqlParser.bindingsClause_return retval = new SparqlParser.bindingsClause_return();
 4778  7144
         retval.start = input.LT(1);
 4779  
 
 4780  
 
 4781  7144
         Object root_0 = null;
 4782  1834
 
 4783  8978
         Token BINDINGS99=null;
 4784  7144
         Token char_literal101=null;
 4785  7144
         Token char_literal103=null;
 4786  8978
         SparqlParser.var_return var100 =null;
 4787  
 
 4788  8978
         SparqlParser.bindingValueList_return bindingValueList102 =null;
 4789  1834
 
 4790  1834
 
 4791  8978
         Object BINDINGS99_tree=null;
 4792  7144
         Object char_literal101_tree=null;
 4793  8978
         Object char_literal103_tree=null;
 4794  7144
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 4795  7144
         RewriteRuleTokenStream stream_BINDINGS=new RewriteRuleTokenStream(adaptor,"token BINDINGS");
 4796  8978
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 4797  8978
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4798  8978
         RewriteRuleSubtreeStream stream_bindingValueList=new RewriteRuleSubtreeStream(adaptor,"rule bindingValueList");
 4799  1834
         try {
 4800  1834
             // com\\googlecode\\sparkleg\\Sparql.g:199:5: ( ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? )
 4801  1834
             // com\\googlecode\\sparkleg\\Sparql.g:199:7: ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )?
 4802  1834
             {
 4803  1834
             // com\\googlecode\\sparkleg\\Sparql.g:199:7: ( BINDINGS ( var )* '{' ( bindingValueList )* '}' )?
 4804  7144
             int alt38=2;
 4805  7144
             switch ( input.LA(1) ) {
 4806  
                 case BINDINGS:
 4807  
                     {
 4808  104
                     alt38=1;
 4809  1834
                     }
 4810  1834
                     break;
 4811  
             }
 4812  
 
 4813  7170
             switch (alt38) {
 4814  
                 case 1 :
 4815  
                     // com\\googlecode\\sparkleg\\Sparql.g:199:8: BINDINGS ( var )* '{' ( bindingValueList )* '}'
 4816  
                     {
 4817  104
                     BINDINGS99=(Token)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause1321);  
 4818  1938
                     stream_BINDINGS.add(BINDINGS99);
 4819  
 
 4820  
 
 4821  
                     // com\\googlecode\\sparkleg\\Sparql.g:199:17: ( var )*
 4822  26
                     loop36:
 4823  26
                     do {
 4824  256
                         int alt36=2;
 4825  256
                         switch ( input.LA(1) ) {
 4826  
                         case VAR1:
 4827  
                         case VAR2:
 4828  
                             {
 4829  216
                             alt36=1;
 4830  64
                             }
 4831  
                             break;
 4832  
 
 4833  
                         }
 4834  38
 
 4835  256
                         switch (alt36) {
 4836  
                             case 1 :
 4837  
                                 // com\\googlecode\\sparkleg\\Sparql.g:199:17: var
 4838  
                                 {
 4839  152
                                 pushFollow(FOLLOW_var_in_bindingsClause1323);
 4840  216
                                 var100=var();
 4841  
 
 4842  152
                                 state._fsp--;
 4843  
 
 4844  190
                                 stream_var.add(var100.getTree());
 4845  38
 
 4846  
                                 }
 4847  190
                                 break;
 4848  
 
 4849  38
                             default :
 4850  104
                                 break loop36;
 4851  
                         }
 4852  190
                     } while (true);
 4853  
 
 4854  
 
 4855  130
                     char_literal101=(Token)match(input,216,FOLLOW_216_in_bindingsClause1326);  
 4856  104
                     stream_216.add(char_literal101);
 4857  38
 
 4858  
 
 4859  
                     // com\\googlecode\\sparkleg\\Sparql.g:199:26: ( bindingValueList )*
 4860  26
                     loop37:
 4861  26
                     do {
 4862  240
                         int alt37=2;
 4863  240
                         switch ( input.LA(1) ) {
 4864  
                         case 209:
 4865  
                             {
 4866  136
                             alt37=1;
 4867  60
                             }
 4868  60
                             break;
 4869  
 
 4870  
                         }
 4871  34
 
 4872  240
                         switch (alt37) {
 4873  
                             case 1 :
 4874  
                                 // com\\googlecode\\sparkleg\\Sparql.g:199:26: bindingValueList
 4875  
                                 {
 4876  136
                                 pushFollow(FOLLOW_bindingValueList_in_bindingsClause1328);
 4877  196
                                 bindingValueList102=bindingValueList();
 4878  
 
 4879  136
                                 state._fsp--;
 4880  
 
 4881  170
                                 stream_bindingValueList.add(bindingValueList102.getTree());
 4882  34
 
 4883  
                                 }
 4884  170
                                 break;
 4885  
 
 4886  34
                             default :
 4887  104
                                 break loop37;
 4888  
                         }
 4889  170
                     } while (true);
 4890  
 
 4891  
 
 4892  130
                     char_literal103=(Token)match(input,218,FOLLOW_218_in_bindingsClause1331);  
 4893  104
                     stream_218.add(char_literal103);
 4894  34
 
 4895  
 
 4896  
                     }
 4897  26
                     break;
 4898  26
 
 4899  
             }
 4900  
 
 4901  
 
 4902  
             // AST REWRITE
 4903  
             // elements: BINDINGS, bindingValueList, var
 4904  
             // token labels: 
 4905  
             // rule labels: retval
 4906  
             // token list labels: 
 4907  
             // rule list labels: 
 4908  
             // wildcard labels: 
 4909  7144
             retval.tree = root_0;
 4910  7144
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4911  
 
 4912  7144
             root_0 = (Object)adaptor.nil();
 4913  
             // 199:50: -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4914  1834
             {
 4915  1834
                 // com\\googlecode\\sparkleg\\Sparql.g:199:53: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4916  7144
                 if ( stream_BINDINGS.hasNext()||stream_bindingValueList.hasNext()||stream_var.hasNext() ) {
 4917  1834
                     // com\\googlecode\\sparkleg\\Sparql.g:199:53: ^( BINDINGS ( var )* ( bindingValueList )* )
 4918  
                     {
 4919  104
                     Object root_1 = (Object)adaptor.nil();
 4920  104
                     root_1 = (Object)adaptor.becomeRoot(
 4921  1834
                     stream_BINDINGS.nextNode()
 4922  
                     , root_1);
 4923  
 
 4924  26
                     // com\\googlecode\\sparkleg\\Sparql.g:199:64: ( var )*
 4925  282
                     while ( stream_var.hasNext() ) {
 4926  152
                         adaptor.addChild(root_1, stream_var.nextTree());
 4927  
 
 4928  
                     }
 4929  104
                     stream_var.reset();
 4930  64
 
 4931  38
                     // com\\googlecode\\sparkleg\\Sparql.g:199:69: ( bindingValueList )*
 4932  240
                     while ( stream_bindingValueList.hasNext() ) {
 4933  136
                         adaptor.addChild(root_1, stream_bindingValueList.nextTree());
 4934  26
 
 4935  
                     }
 4936  104
                     stream_bindingValueList.reset();
 4937  60
 
 4938  138
                     adaptor.addChild(root_0, root_1);
 4939  
                     }
 4940  
 
 4941  26
                 }
 4942  7144
                 stream_BINDINGS.reset();
 4943  7170
                 stream_bindingValueList.reset();
 4944  7144
                 stream_var.reset();
 4945  
 
 4946  
             }
 4947  1834
 
 4948  1834
 
 4949  8978
             retval.tree = root_0;
 4950  
 
 4951  
             }
 4952  
 
 4953  7144
             retval.stop = input.LT(-1);
 4954  1834
 
 4955  
 
 4956  7144
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4957  7144
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4958  1834
 
 4959  
         }
 4960  0
         catch (RecognitionException re) {
 4961  1834
             reportError(re);
 4962  1834
             recover(input,re);
 4963  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4964  
 
 4965  
         }
 4966  
 
 4967  0
         finally {
 4968  
                 // do for sure before leaving
 4969  7144
         }
 4970  7144
         return retval;
 4971  
     }
 4972  
     // $ANTLR end "bindingsClause"
 4973  
 
 4974  1834
 
 4975  1834
     public static class bindingValueList_return extends ParserRuleReturnScope {
 4976  
         Object tree;
 4977  136
         public Object getTree() { return tree; }
 4978  
     };
 4979  
 
 4980  34
 
 4981  
     // $ANTLR start "bindingValueList"
 4982  34
     // com\\googlecode\\sparkleg\\Sparql.g:202:1: bindingValueList : '(' ( bindingValue )* ')' -> ^( BINDING_VALUE ( bindingValue )* ) ;
 4983  
     public final SparqlParser.bindingValueList_return bindingValueList() throws RecognitionException {
 4984  136
         SparqlParser.bindingValueList_return retval = new SparqlParser.bindingValueList_return();
 4985  136
         retval.start = input.LT(1);
 4986  
 
 4987  
 
 4988  136
         Object root_0 = null;
 4989  34
 
 4990  170
         Token char_literal104=null;
 4991  136
         Token char_literal106=null;
 4992  136
         SparqlParser.bindingValue_return bindingValue105 =null;
 4993  34
 
 4994  
 
 4995  170
         Object char_literal104_tree=null;
 4996  170
         Object char_literal106_tree=null;
 4997  170
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 4998  136
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 4999  136
         RewriteRuleSubtreeStream stream_bindingValue=new RewriteRuleSubtreeStream(adaptor,"rule bindingValue");
 5000  34
         try {
 5001  34
             // com\\googlecode\\sparkleg\\Sparql.g:203:5: ( '(' ( bindingValue )* ')' -> ^( BINDING_VALUE ( bindingValue )* ) )
 5002  34
             // com\\googlecode\\sparkleg\\Sparql.g:203:7: '(' ( bindingValue )* ')'
 5003  34
             {
 5004  170
             char_literal104=(Token)match(input,209,FOLLOW_209_in_bindingValueList1367);  
 5005  136
             stream_209.add(char_literal104);
 5006  
 
 5007  
 
 5008  
             // com\\googlecode\\sparkleg\\Sparql.g:203:11: ( bindingValue )*
 5009  34
             loop39:
 5010  34
             do {
 5011  352
                 int alt39=2;
 5012  352
                 switch ( input.LA(1) ) {
 5013  
                 case DECIMAL:
 5014  
                 case DECIMAL_NEGATIVE:
 5015  
                 case DECIMAL_POSITIVE:
 5016  88
                 case DOUBLE:
 5017  88
                 case DOUBLE_NEGATIVE:
 5018  
                 case DOUBLE_POSITIVE:
 5019  
                 case FALSE:
 5020  
                 case INTEGER:
 5021  
                 case INTEGER_NEGATIVE:
 5022  
                 case INTEGER_POSITIVE:
 5023  
                 case IRI_REF:
 5024  
                 case PNAME_LN:
 5025  
                 case PNAME_NS:
 5026  
                 case STRING_LITERAL1:
 5027  
                 case STRING_LITERAL2:
 5028  
                 case STRING_LITERAL_LONG1:
 5029  
                 case STRING_LITERAL_LONG2:
 5030  
                 case TRUE:
 5031  
                 case UNDEF:
 5032  
                     {
 5033  216
                     alt39=1;
 5034  
                     }
 5035  
                     break;
 5036  
 
 5037  
                 }
 5038  54
 
 5039  352
                 switch (alt39) {
 5040  
                     case 1 :
 5041  
                         // com\\googlecode\\sparkleg\\Sparql.g:203:11: bindingValue
 5042  
                         {
 5043  216
                         pushFollow(FOLLOW_bindingValue_in_bindingValueList1369);
 5044  304
                         bindingValue105=bindingValue();
 5045  
 
 5046  216
                         state._fsp--;
 5047  
 
 5048  270
                         stream_bindingValue.add(bindingValue105.getTree());
 5049  54
 
 5050  
                         }
 5051  270
                         break;
 5052  
 
 5053  54
                     default :
 5054  136
                         break loop39;
 5055  
                 }
 5056  270
             } while (true);
 5057  
 
 5058  
 
 5059  170
             char_literal106=(Token)match(input,210,FOLLOW_210_in_bindingValueList1372);  
 5060  136
             stream_210.add(char_literal106);
 5061  54
 
 5062  
 
 5063  
             // AST REWRITE
 5064  34
             // elements: bindingValue
 5065  34
             // token labels: 
 5066  
             // rule labels: retval
 5067  
             // token list labels: 
 5068  
             // rule list labels: 
 5069  
             // wildcard labels: 
 5070  136
             retval.tree = root_0;
 5071  136
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5072  
 
 5073  136
             root_0 = (Object)adaptor.nil();
 5074  
             // 203:29: -> ^( BINDING_VALUE ( bindingValue )* )
 5075  34
             {
 5076  34
                 // com\\googlecode\\sparkleg\\Sparql.g:203:32: ^( BINDING_VALUE ( bindingValue )* )
 5077  
                 {
 5078  170
                 Object root_1 = (Object)adaptor.nil();
 5079  136
                 root_1 = (Object)adaptor.becomeRoot(
 5080  
                 (Object)adaptor.create(BINDING_VALUE, "BINDING_VALUE")
 5081  
                 , root_1);
 5082  
 
 5083  34
                 // com\\googlecode\\sparkleg\\Sparql.g:203:48: ( bindingValue )*
 5084  386
                 while ( stream_bindingValue.hasNext() ) {
 5085  216
                     adaptor.addChild(root_1, stream_bindingValue.nextTree());
 5086  
 
 5087  
                 }
 5088  136
                 stream_bindingValue.reset();
 5089  88
 
 5090  190
                 adaptor.addChild(root_0, root_1);
 5091  
                 }
 5092  
 
 5093  34
             }
 5094  
 
 5095  34
 
 5096  136
             retval.tree = root_0;
 5097  
 
 5098  
             }
 5099  
 
 5100  136
             retval.stop = input.LT(-1);
 5101  34
 
 5102  
 
 5103  136
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5104  136
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5105  34
 
 5106  
         }
 5107  0
         catch (RecognitionException re) {
 5108  34
             reportError(re);
 5109  34
             recover(input,re);
 5110  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5111  
 
 5112  
         }
 5113  
 
 5114  0
         finally {
 5115  
                 // do for sure before leaving
 5116  136
         }
 5117  136
         return retval;
 5118  
     }
 5119  
     // $ANTLR end "bindingValueList"
 5120  
 
 5121  34
 
 5122  34
     public static class bindingValue_return extends ParserRuleReturnScope {
 5123  
         Object tree;
 5124  216
         public Object getTree() { return tree; }
 5125  
     };
 5126  
 
 5127  54
 
 5128  
     // $ANTLR start "bindingValue"
 5129  54
     // com\\googlecode\\sparkleg\\Sparql.g:206:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 5130  
     public final SparqlParser.bindingValue_return bindingValue() throws RecognitionException {
 5131  216
         SparqlParser.bindingValue_return retval = new SparqlParser.bindingValue_return();
 5132  216
         retval.start = input.LT(1);
 5133  
 
 5134  
 
 5135  216
         Object root_0 = null;
 5136  54
 
 5137  270
         Token UNDEF111=null;
 5138  216
         SparqlParser.iriRef_return iriRef107 =null;
 5139  
 
 5140  270
         SparqlParser.rdfLiteral_return rdfLiteral108 =null;
 5141  
 
 5142  270
         SparqlParser.numericLiteral_return numericLiteral109 =null;
 5143  54
 
 5144  216
         SparqlParser.booleanLiteral_return booleanLiteral110 =null;
 5145  54
 
 5146  
 
 5147  270
         Object UNDEF111_tree=null;
 5148  
 
 5149  54
         try {
 5150  
             // com\\googlecode\\sparkleg\\Sparql.g:207:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 5151  216
             int alt40=5;
 5152  270
             switch ( input.LA(1) ) {
 5153  
             case IRI_REF:
 5154  
             case PNAME_LN:
 5155  
             case PNAME_NS:
 5156  54
                 {
 5157  142
                 alt40=1;
 5158  
                 }
 5159  88
                 break;
 5160  
             case STRING_LITERAL1:
 5161  
             case STRING_LITERAL2:
 5162  22
             case STRING_LITERAL_LONG1:
 5163  
             case STRING_LITERAL_LONG2:
 5164  22
                 {
 5165  56
                 alt40=2;
 5166  
                 }
 5167  56
                 break;
 5168  
             case DECIMAL:
 5169  
             case DECIMAL_NEGATIVE:
 5170  14
             case DECIMAL_POSITIVE:
 5171  
             case DOUBLE:
 5172  14
             case DOUBLE_NEGATIVE:
 5173  
             case DOUBLE_POSITIVE:
 5174  
             case INTEGER:
 5175  
             case INTEGER_NEGATIVE:
 5176  
             case INTEGER_POSITIVE:
 5177  
                 {
 5178  0
                 alt40=3;
 5179  
                 }
 5180  0
                 break;
 5181  
             case FALSE:
 5182  
             case TRUE:
 5183  
                 {
 5184  0
                 alt40=4;
 5185  
                 }
 5186  0
                 break;
 5187  
             case UNDEF:
 5188  
                 {
 5189  72
                 alt40=5;
 5190  
                 }
 5191  72
                 break;
 5192  
             default:
 5193  0
                 NoViableAltException nvae =
 5194  18
                     new NoViableAltException("", 40, 0, input);
 5195  
 
 5196  18
                 throw nvae;
 5197  
 
 5198  
             }
 5199  
 
 5200  216
             switch (alt40) {
 5201  
                 case 1 :
 5202  
                     // com\\googlecode\\sparkleg\\Sparql.g:207:7: iriRef
 5203  
                     {
 5204  88
                     root_0 = (Object)adaptor.nil();
 5205  54
 
 5206  
 
 5207  88
                     pushFollow(FOLLOW_iriRef_in_bindingValue1403);
 5208  88
                     iriRef107=iriRef();
 5209  22
 
 5210  88
                     state._fsp--;
 5211  
 
 5212  110
                     adaptor.addChild(root_0, iriRef107.getTree());
 5213  22
 
 5214  
                     }
 5215  110
                     break;
 5216  
                 case 2 :
 5217  22
                     // com\\googlecode\\sparkleg\\Sparql.g:207:16: rdfLiteral
 5218  
                     {
 5219  56
                     root_0 = (Object)adaptor.nil();
 5220  22
 
 5221  
 
 5222  56
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue1407);
 5223  56
                     rdfLiteral108=rdfLiteral();
 5224  14
 
 5225  56
                     state._fsp--;
 5226  
 
 5227  70
                     adaptor.addChild(root_0, rdfLiteral108.getTree());
 5228  14
 
 5229  
                     }
 5230  70
                     break;
 5231  
                 case 3 :
 5232  14
                     // com\\googlecode\\sparkleg\\Sparql.g:207:29: numericLiteral
 5233  
                     {
 5234  0
                     root_0 = (Object)adaptor.nil();
 5235  14
 
 5236  
 
 5237  0
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue1411);
 5238  0
                     numericLiteral109=numericLiteral();
 5239  
 
 5240  0
                     state._fsp--;
 5241  
 
 5242  0
                     adaptor.addChild(root_0, numericLiteral109.getTree());
 5243  
 
 5244  
                     }
 5245  0
                     break;
 5246  
                 case 4 :
 5247  
                     // com\\googlecode\\sparkleg\\Sparql.g:207:46: booleanLiteral
 5248  
                     {
 5249  0
                     root_0 = (Object)adaptor.nil();
 5250  
 
 5251  
 
 5252  0
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue1415);
 5253  0
                     booleanLiteral110=booleanLiteral();
 5254  
 
 5255  0
                     state._fsp--;
 5256  
 
 5257  0
                     adaptor.addChild(root_0, booleanLiteral110.getTree());
 5258  
 
 5259  
                     }
 5260  0
                     break;
 5261  
                 case 5 :
 5262  
                     // com\\googlecode\\sparkleg\\Sparql.g:207:63: UNDEF
 5263  
                     {
 5264  72
                     root_0 = (Object)adaptor.nil();
 5265  
 
 5266  
 
 5267  72
                     UNDEF111=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue1419); 
 5268  72
                     UNDEF111_tree = 
 5269  18
                     (Object)adaptor.create(UNDEF111)
 5270  
                     ;
 5271  72
                     adaptor.addChild(root_0, UNDEF111_tree);
 5272  18
 
 5273  18
 
 5274  
                     }
 5275  
                     break;
 5276  18
 
 5277  
             }
 5278  216
             retval.stop = input.LT(-1);
 5279  
 
 5280  
 
 5281  216
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5282  216
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5283  54
 
 5284  
         }
 5285  0
         catch (RecognitionException re) {
 5286  54
             reportError(re);
 5287  54
             recover(input,re);
 5288  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5289  
 
 5290  
         }
 5291  
 
 5292  0
         finally {
 5293  
                 // do for sure before leaving
 5294  216
         }
 5295  216
         return retval;
 5296  
     }
 5297  
     // $ANTLR end "bindingValue"
 5298  
 
 5299  54
 
 5300  54
     public static class update_return extends ParserRuleReturnScope {
 5301  
         Object tree;
 5302  512
         public Object getTree() { return tree; }
 5303  
     };
 5304  
 
 5305  128
 
 5306  
     // $ANTLR start "update"
 5307  128
     // com\\googlecode\\sparkleg\\Sparql.g:210:1: update : prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 5308  
     public final SparqlParser.update_return update() throws RecognitionException {
 5309  512
         SparqlParser.update_return retval = new SparqlParser.update_return();
 5310  512
         retval.start = input.LT(1);
 5311  
 
 5312  
 
 5313  512
         Object root_0 = null;
 5314  128
 
 5315  640
         SparqlParser.prologue_return prologue112 =null;
 5316  
 
 5317  512
         SparqlParser.load_return load113 =null;
 5318  128
 
 5319  512
         SparqlParser.clear_return clear114 =null;
 5320  128
 
 5321  512
         SparqlParser.drop_return drop115 =null;
 5322  128
 
 5323  512
         SparqlParser.add_return add116 =null;
 5324  128
 
 5325  512
         SparqlParser.move_return move117 =null;
 5326  128
 
 5327  512
         SparqlParser.copy_return copy118 =null;
 5328  128
 
 5329  512
         SparqlParser.create_return create119 =null;
 5330  128
 
 5331  512
         SparqlParser.insert_return insert120 =null;
 5332  128
 
 5333  512
         SparqlParser.delete_return delete121 =null;
 5334  128
 
 5335  512
         SparqlParser.modify_return modify122 =null;
 5336  128
 
 5337  
 
 5338  640
         RewriteRuleSubtreeStream stream_clear=new RewriteRuleSubtreeStream(adaptor,"rule clear");
 5339  512
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 5340  640
         RewriteRuleSubtreeStream stream_drop=new RewriteRuleSubtreeStream(adaptor,"rule drop");
 5341  512
         RewriteRuleSubtreeStream stream_delete=new RewriteRuleSubtreeStream(adaptor,"rule delete");
 5342  512
         RewriteRuleSubtreeStream stream_modify=new RewriteRuleSubtreeStream(adaptor,"rule modify");
 5343  640
         RewriteRuleSubtreeStream stream_load=new RewriteRuleSubtreeStream(adaptor,"rule load");
 5344  640
         RewriteRuleSubtreeStream stream_add=new RewriteRuleSubtreeStream(adaptor,"rule add");
 5345  640
         RewriteRuleSubtreeStream stream_insert=new RewriteRuleSubtreeStream(adaptor,"rule insert");
 5346  640
         RewriteRuleSubtreeStream stream_create=new RewriteRuleSubtreeStream(adaptor,"rule create");
 5347  640
         RewriteRuleSubtreeStream stream_move=new RewriteRuleSubtreeStream(adaptor,"rule move");
 5348  640
         RewriteRuleSubtreeStream stream_copy=new RewriteRuleSubtreeStream(adaptor,"rule copy");
 5349  128
         try {
 5350  128
             // com\\googlecode\\sparkleg\\Sparql.g:211:5: ( prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 5351  128
             // com\\googlecode\\sparkleg\\Sparql.g:211:7: prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5352  128
             {
 5353  640
             pushFollow(FOLLOW_prologue_in_update1440);
 5354  512
             prologue112=prologue();
 5355  
 
 5356  512
             state._fsp--;
 5357  
 
 5358  640
             stream_prologue.add(prologue112.getTree());
 5359  128
 
 5360  
             // com\\googlecode\\sparkleg\\Sparql.g:211:16: ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5361  640
             int alt41=10;
 5362  512
             switch ( input.LA(1) ) {
 5363  128
             case LOAD:
 5364  
                 {
 5365  0
                 alt41=1;
 5366  128
                 }
 5367  128
                 break;
 5368  
             case CLEAR:
 5369  
                 {
 5370  32
                 alt41=2;
 5371  
                 }
 5372  32
                 break;
 5373  
             case DROP:
 5374  
                 {
 5375  40
                 alt41=3;
 5376  
                 }
 5377  40
                 break;
 5378  
             case ADD:
 5379  
                 {
 5380  8
                 alt41=4;
 5381  
                 }
 5382  8
                 break;
 5383  
             case MOVE:
 5384  
                 {
 5385  0
                 alt41=5;
 5386  
                 }
 5387  0
                 break;
 5388  
             case COPY:
 5389  
                 {
 5390  0
                 alt41=6;
 5391  
                 }
 5392  0
                 break;
 5393  
             case CREATE:
 5394  
                 {
 5395  0
                 alt41=7;
 5396  
                 }
 5397  0
                 break;
 5398  
             case INSERT:
 5399  
                 {
 5400  80
                 switch ( input.LA(2) ) {
 5401  
                 case DATA:
 5402  
                     {
 5403  32
                     alt41=8;
 5404  
                     }
 5405  52
                     break;
 5406  
                 case 216:
 5407  
                     {
 5408  56
                     alt41=10;
 5409  
                     }
 5410  56
                     break;
 5411  
                 default:
 5412  0
                     NoViableAltException nvae =
 5413  12
                         new NoViableAltException("", 41, 8, input);
 5414  
 
 5415  12
                     throw nvae;
 5416  
 
 5417  
                 }
 5418  
 
 5419  
                 }
 5420  80
                 break;
 5421  
             case DELETE:
 5422  
                 {
 5423  312
                 switch ( input.LA(2) ) {
 5424  
                 case DATA:
 5425  20
                 case WHERE:
 5426  
                     {
 5427  96
                     alt41=9;
 5428  78
                     }
 5429  96
                     break;
 5430  
                 case 216:
 5431  
                     {
 5432  240
                     alt41=10;
 5433  
                     }
 5434  240
                     break;
 5435  
                 default:
 5436  0
                     NoViableAltException nvae =
 5437  54
                         new NoViableAltException("", 41, 9, input);
 5438  
 
 5439  54
                     throw nvae;
 5440  
 
 5441  
                 }
 5442  
 
 5443  
                 }
 5444  312
                 break;
 5445  
             case WITH:
 5446  
                 {
 5447  56
                 alt41=10;
 5448  
                 }
 5449  134
                 break;
 5450  
             default:
 5451  0
                 NoViableAltException nvae =
 5452  14
                     new NoViableAltException("", 41, 0, input);
 5453  
 
 5454  14
                 throw nvae;
 5455  
 
 5456  
             }
 5457  
 
 5458  512
             switch (alt41) {
 5459  
                 case 1 :
 5460  
                     // com\\googlecode\\sparkleg\\Sparql.g:211:17: load
 5461  
                     {
 5462  0
                     pushFollow(FOLLOW_load_in_update1443);
 5463  128
                     load113=load();
 5464  
 
 5465  0
                     state._fsp--;
 5466  
 
 5467  0
                     stream_load.add(load113.getTree());
 5468  
 
 5469  
                     }
 5470  0
                     break;
 5471  
                 case 2 :
 5472  
                     // com\\googlecode\\sparkleg\\Sparql.g:211:24: clear
 5473  
                     {
 5474  32
                     pushFollow(FOLLOW_clear_in_update1447);
 5475  32
                     clear114=clear();
 5476  
 
 5477  32
                     state._fsp--;
 5478  
 
 5479  40
                     stream_clear.add(clear114.getTree());
 5480  8
 
 5481  
                     }
 5482  40
                     break;
 5483  
                 case 3 :
 5484  8
                     // com\\googlecode\\sparkleg\\Sparql.g:211:32: drop
 5485  
                     {
 5486  32
                     pushFollow(FOLLOW_drop_in_update1451);
 5487  40
                     drop115=drop();
 5488  
 
 5489  32
                     state._fsp--;
 5490  
 
 5491  40
                     stream_drop.add(drop115.getTree());
 5492  8
 
 5493  
                     }
 5494  40
                     break;
 5495  
                 case 4 :
 5496  8
                     // com\\googlecode\\sparkleg\\Sparql.g:211:39: add
 5497  
                     {
 5498  0
                     pushFollow(FOLLOW_add_in_update1455);
 5499  8
                     add116=add();
 5500  
 
 5501  0
                     state._fsp--;
 5502  
 
 5503  0
                     stream_add.add(add116.getTree());
 5504  
 
 5505  
                     }
 5506  0
                     break;
 5507  
                 case 5 :
 5508  
                     // com\\googlecode\\sparkleg\\Sparql.g:211:45: move
 5509  
                     {
 5510  0
                     pushFollow(FOLLOW_move_in_update1459);
 5511  0
                     move117=move();
 5512  
 
 5513  0
                     state._fsp--;
 5514  
 
 5515  0
                     stream_move.add(move117.getTree());
 5516  
 
 5517  
                     }
 5518  0
                     break;
 5519  
                 case 6 :
 5520  
                     // com\\googlecode\\sparkleg\\Sparql.g:211:52: copy
 5521  
                     {
 5522  0
                     pushFollow(FOLLOW_copy_in_update1463);
 5523  0
                     copy118=copy();
 5524  
 
 5525  0
                     state._fsp--;
 5526  
 
 5527  0
                     stream_copy.add(copy118.getTree());
 5528  
 
 5529  
                     }
 5530  0
                     break;
 5531  
                 case 7 :
 5532  
                     // com\\googlecode\\sparkleg\\Sparql.g:211:59: create
 5533  
                     {
 5534  0
                     pushFollow(FOLLOW_create_in_update1467);
 5535  0
                     create119=create();
 5536  
 
 5537  0
                     state._fsp--;
 5538  
 
 5539  0
                     stream_create.add(create119.getTree());
 5540  
 
 5541  
                     }
 5542  0
                     break;
 5543  
                 case 8 :
 5544  
                     // com\\googlecode\\sparkleg\\Sparql.g:211:68: insert
 5545  
                     {
 5546  32
                     pushFollow(FOLLOW_insert_in_update1471);
 5547  32
                     insert120=insert();
 5548  
 
 5549  32
                     state._fsp--;
 5550  
 
 5551  40
                     stream_insert.add(insert120.getTree());
 5552  8
 
 5553  
                     }
 5554  40
                     break;
 5555  
                 case 9 :
 5556  8
                     // com\\googlecode\\sparkleg\\Sparql.g:211:77: delete
 5557  
                     {
 5558  96
                     pushFollow(FOLLOW_delete_in_update1475);
 5559  104
                     delete121=delete();
 5560  
 
 5561  96
                     state._fsp--;
 5562  
 
 5563  120
                     stream_delete.add(delete121.getTree());
 5564  24
 
 5565  
                     }
 5566  120
                     break;
 5567  
                 case 10 :
 5568  24
                     // com\\googlecode\\sparkleg\\Sparql.g:211:86: modify
 5569  
                     {
 5570  320
                     pushFollow(FOLLOW_modify_in_update1479);
 5571  344
                     modify122=modify();
 5572  
 
 5573  320
                     state._fsp--;
 5574  
 
 5575  400
                     stream_modify.add(modify122.getTree());
 5576  80
 
 5577  
                     }
 5578  80
                     break;
 5579  
 
 5580  80
             }
 5581  
 
 5582  
 
 5583  
             // AST REWRITE
 5584  
             // elements: delete, add, prologue, insert, create, move, copy, clear, load, modify, drop
 5585  
             // token labels: 
 5586  
             // rule labels: retval
 5587  
             // token list labels: 
 5588  
             // rule list labels: 
 5589  
             // wildcard labels: 
 5590  512
             retval.tree = root_0;
 5591  512
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5592  
 
 5593  512
             root_0 = (Object)adaptor.nil();
 5594  
             // 211:94: -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 5595  128
             {
 5596  640
                 adaptor.addChild(root_0, stream_prologue.nextTree());
 5597  
 
 5598  128
                 // com\\googlecode\\sparkleg\\Sparql.g:211:106: ( load )*
 5599  512
                 while ( stream_load.hasNext() ) {
 5600  0
                     adaptor.addChild(root_0, stream_load.nextTree());
 5601  128
 
 5602  
                 }
 5603  512
                 stream_load.reset();
 5604  128
 
 5605  
                 // com\\googlecode\\sparkleg\\Sparql.g:211:112: ( clear )*
 5606  544
                 while ( stream_clear.hasNext() ) {
 5607  32
                     adaptor.addChild(root_0, stream_clear.nextTree());
 5608  128
 
 5609  
                 }
 5610  512
                 stream_clear.reset();
 5611  136
 
 5612  8
                 // com\\googlecode\\sparkleg\\Sparql.g:211:119: ( drop )*
 5613  544
                 while ( stream_drop.hasNext() ) {
 5614  32
                     adaptor.addChild(root_0, stream_drop.nextTree());
 5615  128
 
 5616  
                 }
 5617  512
                 stream_drop.reset();
 5618  136
 
 5619  8
                 // com\\googlecode\\sparkleg\\Sparql.g:211:125: ( add )*
 5620  512
                 while ( stream_add.hasNext() ) {
 5621  0
                     adaptor.addChild(root_0, stream_add.nextTree());
 5622  128
 
 5623  
                 }
 5624  512
                 stream_add.reset();
 5625  128
 
 5626  
                 // com\\googlecode\\sparkleg\\Sparql.g:211:130: ( move )*
 5627  512
                 while ( stream_move.hasNext() ) {
 5628  0
                     adaptor.addChild(root_0, stream_move.nextTree());
 5629  128
 
 5630  
                 }
 5631  512
                 stream_move.reset();
 5632  128
 
 5633  
                 // com\\googlecode\\sparkleg\\Sparql.g:211:136: ( copy )*
 5634  512
                 while ( stream_copy.hasNext() ) {
 5635  0
                     adaptor.addChild(root_0, stream_copy.nextTree());
 5636  128
 
 5637  
                 }
 5638  512
                 stream_copy.reset();
 5639  128
 
 5640  
                 // com\\googlecode\\sparkleg\\Sparql.g:211:142: ( create )*
 5641  512
                 while ( stream_create.hasNext() ) {
 5642  0
                     adaptor.addChild(root_0, stream_create.nextTree());
 5643  128
 
 5644  
                 }
 5645  512
                 stream_create.reset();
 5646  128
 
 5647  
                 // com\\googlecode\\sparkleg\\Sparql.g:211:150: ( insert )*
 5648  544
                 while ( stream_insert.hasNext() ) {
 5649  32
                     adaptor.addChild(root_0, stream_insert.nextTree());
 5650  128
 
 5651  
                 }
 5652  512
                 stream_insert.reset();
 5653  136
 
 5654  8
                 // com\\googlecode\\sparkleg\\Sparql.g:211:158: ( delete )*
 5655  608
                 while ( stream_delete.hasNext() ) {
 5656  96
                     adaptor.addChild(root_0, stream_delete.nextTree());
 5657  128
 
 5658  
                 }
 5659  512
                 stream_delete.reset();
 5660  152
 
 5661  24
                 // com\\googlecode\\sparkleg\\Sparql.g:211:166: ( modify )*
 5662  832
                 while ( stream_modify.hasNext() ) {
 5663  320
                     adaptor.addChild(root_0, stream_modify.nextTree());
 5664  128
 
 5665  
                 }
 5666  512
                 stream_modify.reset();
 5667  208
 
 5668  80
             }
 5669  
 
 5670  
 
 5671  640
             retval.tree = root_0;
 5672  
 
 5673  
             }
 5674  
 
 5675  512
             retval.stop = input.LT(-1);
 5676  128
 
 5677  
 
 5678  512
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5679  512
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5680  128
 
 5681  
         }
 5682  0
         catch (RecognitionException re) {
 5683  128
             reportError(re);
 5684  128
             recover(input,re);
 5685  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5686  
 
 5687  
         }
 5688  
 
 5689  0
         finally {
 5690  
                 // do for sure before leaving
 5691  512
         }
 5692  512
         return retval;
 5693  
     }
 5694  
     // $ANTLR end "update"
 5695  
 
 5696  128
 
 5697  128
     public static class load_return extends ParserRuleReturnScope {
 5698  
         Object tree;
 5699  0
         public Object getTree() { return tree; }
 5700  
     };
 5701  
 
 5702  
 
 5703  
     // $ANTLR start "load"
 5704  
     // com\\googlecode\\sparkleg\\Sparql.g:214:1: load : LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5705  
     public final SparqlParser.load_return load() throws RecognitionException {
 5706  0
         SparqlParser.load_return retval = new SparqlParser.load_return();
 5707  0
         retval.start = input.LT(1);
 5708  
 
 5709  
 
 5710  0
         Object root_0 = null;
 5711  
 
 5712  0
         Token LOAD123=null;
 5713  0
         Token SILENT124=null;
 5714  0
         Token INTO126=null;
 5715  0
         SparqlParser.iriRef_return iriRef125 =null;
 5716  
 
 5717  0
         SparqlParser.graphRef_return graphRef127 =null;
 5718  
 
 5719  
 
 5720  0
         Object LOAD123_tree=null;
 5721  0
         Object SILENT124_tree=null;
 5722  0
         Object INTO126_tree=null;
 5723  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5724  0
         RewriteRuleTokenStream stream_INTO=new RewriteRuleTokenStream(adaptor,"token INTO");
 5725  0
         RewriteRuleTokenStream stream_LOAD=new RewriteRuleTokenStream(adaptor,"token LOAD");
 5726  0
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 5727  0
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 5728  
         try {
 5729  
             // com\\googlecode\\sparkleg\\Sparql.g:215:5: ( LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5730  
             // com\\googlecode\\sparkleg\\Sparql.g:215:7: LOAD ( SILENT )? iriRef ( INTO graphRef )?
 5731  
             {
 5732  0
             LOAD123=(Token)match(input,LOAD,FOLLOW_LOAD_in_load1542);  
 5733  0
             stream_LOAD.add(LOAD123);
 5734  
 
 5735  
 
 5736  
             // com\\googlecode\\sparkleg\\Sparql.g:215:12: ( SILENT )?
 5737  0
             int alt42=2;
 5738  0
             switch ( input.LA(1) ) {
 5739  
                 case SILENT:
 5740  
                     {
 5741  0
                     alt42=1;
 5742  
                     }
 5743  
                     break;
 5744  
             }
 5745  
 
 5746  0
             switch (alt42) {
 5747  
                 case 1 :
 5748  
                     // com\\googlecode\\sparkleg\\Sparql.g:215:12: SILENT
 5749  
                     {
 5750  0
                     SILENT124=(Token)match(input,SILENT,FOLLOW_SILENT_in_load1544);  
 5751  0
                     stream_SILENT.add(SILENT124);
 5752  
 
 5753  
 
 5754  
                     }
 5755  
                     break;
 5756  
 
 5757  
             }
 5758  
 
 5759  
 
 5760  0
             pushFollow(FOLLOW_iriRef_in_load1547);
 5761  0
             iriRef125=iriRef();
 5762  
 
 5763  0
             state._fsp--;
 5764  
 
 5765  0
             stream_iriRef.add(iriRef125.getTree());
 5766  
 
 5767  
             // com\\googlecode\\sparkleg\\Sparql.g:215:27: ( INTO graphRef )?
 5768  0
             int alt43=2;
 5769  0
             switch ( input.LA(1) ) {
 5770  
                 case INTO:
 5771  
                     {
 5772  0
                     alt43=1;
 5773  
                     }
 5774  
                     break;
 5775  
             }
 5776  
 
 5777  0
             switch (alt43) {
 5778  
                 case 1 :
 5779  
                     // com\\googlecode\\sparkleg\\Sparql.g:215:28: INTO graphRef
 5780  
                     {
 5781  0
                     INTO126=(Token)match(input,INTO,FOLLOW_INTO_in_load1550);  
 5782  0
                     stream_INTO.add(INTO126);
 5783  
 
 5784  
 
 5785  0
                     pushFollow(FOLLOW_graphRef_in_load1552);
 5786  0
                     graphRef127=graphRef();
 5787  
 
 5788  0
                     state._fsp--;
 5789  
 
 5790  0
                     stream_graphRef.add(graphRef127.getTree());
 5791  
 
 5792  
                     }
 5793  
                     break;
 5794  
 
 5795  
             }
 5796  
 
 5797  
 
 5798  
             // AST REWRITE
 5799  
             // elements: graphRef, SILENT, LOAD, iriRef
 5800  
             // token labels: 
 5801  
             // rule labels: retval
 5802  
             // token list labels: 
 5803  
             // rule list labels: 
 5804  
             // wildcard labels: 
 5805  0
             retval.tree = root_0;
 5806  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5807  
 
 5808  0
             root_0 = (Object)adaptor.nil();
 5809  
             // 215:44: -> ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5810  
             {
 5811  
                 // com\\googlecode\\sparkleg\\Sparql.g:215:47: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5812  
                 {
 5813  0
                 Object root_1 = (Object)adaptor.nil();
 5814  0
                 root_1 = (Object)adaptor.becomeRoot(
 5815  
                 stream_LOAD.nextNode()
 5816  
                 , root_1);
 5817  
 
 5818  
                 // com\\googlecode\\sparkleg\\Sparql.g:215:54: ( SILENT )*
 5819  0
                 while ( stream_SILENT.hasNext() ) {
 5820  0
                     adaptor.addChild(root_1, 
 5821  
                     stream_SILENT.nextNode()
 5822  
                     );
 5823  
 
 5824  
                 }
 5825  0
                 stream_SILENT.reset();
 5826  
 
 5827  0
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 5828  
 
 5829  
                 // com\\googlecode\\sparkleg\\Sparql.g:215:69: ( graphRef )?
 5830  0
                 if ( stream_graphRef.hasNext() ) {
 5831  0
                     adaptor.addChild(root_1, stream_graphRef.nextTree());
 5832  
 
 5833  
                 }
 5834  0
                 stream_graphRef.reset();
 5835  
 
 5836  0
                 adaptor.addChild(root_0, root_1);
 5837  
                 }
 5838  
 
 5839  
             }
 5840  
 
 5841  
 
 5842  0
             retval.tree = root_0;
 5843  
 
 5844  
             }
 5845  
 
 5846  0
             retval.stop = input.LT(-1);
 5847  
 
 5848  
 
 5849  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5850  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5851  
 
 5852  
         }
 5853  0
         catch (RecognitionException re) {
 5854  0
             reportError(re);
 5855  0
             recover(input,re);
 5856  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5857  
 
 5858  
         }
 5859  
 
 5860  0
         finally {
 5861  
                 // do for sure before leaving
 5862  0
         }
 5863  0
         return retval;
 5864  
     }
 5865  
     // $ANTLR end "load"
 5866  
 
 5867  
 
 5868  32
     public static class clear_return extends ParserRuleReturnScope {
 5869  
         Object tree;
 5870  32
         public Object getTree() { return tree; }
 5871  
     };
 5872  
 
 5873  8
 
 5874  
     // $ANTLR start "clear"
 5875  8
     // com\\googlecode\\sparkleg\\Sparql.g:218:1: clear : CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) ;
 5876  
     public final SparqlParser.clear_return clear() throws RecognitionException {
 5877  32
         SparqlParser.clear_return retval = new SparqlParser.clear_return();
 5878  32
         retval.start = input.LT(1);
 5879  
 
 5880  
 
 5881  32
         Object root_0 = null;
 5882  8
 
 5883  40
         Token CLEAR128=null;
 5884  32
         Token SILENT129=null;
 5885  32
         SparqlParser.graphRefAll_return graphRefAll130 =null;
 5886  8
 
 5887  
 
 5888  40
         Object CLEAR128_tree=null;
 5889  40
         Object SILENT129_tree=null;
 5890  40
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5891  32
         RewriteRuleTokenStream stream_CLEAR=new RewriteRuleTokenStream(adaptor,"token CLEAR");
 5892  32
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5893  8
         try {
 5894  8
             // com\\googlecode\\sparkleg\\Sparql.g:219:5: ( CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) )
 5895  8
             // com\\googlecode\\sparkleg\\Sparql.g:219:7: CLEAR ( SILENT )? graphRefAll
 5896  8
             {
 5897  40
             CLEAR128=(Token)match(input,CLEAR,FOLLOW_CLEAR_in_clear1589);  
 5898  32
             stream_CLEAR.add(CLEAR128);
 5899  
 
 5900  
 
 5901  
             // com\\googlecode\\sparkleg\\Sparql.g:219:14: ( SILENT )?
 5902  40
             int alt44=2;
 5903  40
             switch ( input.LA(1) ) {
 5904  
                 case SILENT:
 5905  
                     {
 5906  0
                     alt44=1;
 5907  8
                     }
 5908  8
                     break;
 5909  
             }
 5910  
 
 5911  32
             switch (alt44) {
 5912  
                 case 1 :
 5913  
                     // com\\googlecode\\sparkleg\\Sparql.g:219:14: SILENT
 5914  
                     {
 5915  0
                     SILENT129=(Token)match(input,SILENT,FOLLOW_SILENT_in_clear1592);  
 5916  8
                     stream_SILENT.add(SILENT129);
 5917  
 
 5918  
 
 5919  
                     }
 5920  
                     break;
 5921  
 
 5922  
             }
 5923  
 
 5924  
 
 5925  32
             pushFollow(FOLLOW_graphRefAll_in_clear1595);
 5926  32
             graphRefAll130=graphRefAll();
 5927  
 
 5928  32
             state._fsp--;
 5929  
 
 5930  40
             stream_graphRefAll.add(graphRefAll130.getTree());
 5931  8
 
 5932  
             // AST REWRITE
 5933  8
             // elements: CLEAR, graphRefAll, SILENT
 5934  
             // token labels: 
 5935  8
             // rule labels: retval
 5936  
             // token list labels: 
 5937  
             // rule list labels: 
 5938  
             // wildcard labels: 
 5939  32
             retval.tree = root_0;
 5940  32
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5941  
 
 5942  32
             root_0 = (Object)adaptor.nil();
 5943  
             // 219:34: -> ^( CLEAR ( SILENT )* graphRefAll )
 5944  8
             {
 5945  8
                 // com\\googlecode\\sparkleg\\Sparql.g:219:37: ^( CLEAR ( SILENT )* graphRefAll )
 5946  
                 {
 5947  40
                 Object root_1 = (Object)adaptor.nil();
 5948  32
                 root_1 = (Object)adaptor.becomeRoot(
 5949  
                 stream_CLEAR.nextNode()
 5950  
                 , root_1);
 5951  
 
 5952  8
                 // com\\googlecode\\sparkleg\\Sparql.g:219:45: ( SILENT )*
 5953  40
                 while ( stream_SILENT.hasNext() ) {
 5954  0
                     adaptor.addChild(root_1, 
 5955  
                     stream_SILENT.nextNode()
 5956  
                     );
 5957  
 
 5958  8
                 }
 5959  32
                 stream_SILENT.reset();
 5960  
 
 5961  32
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 5962  
 
 5963  32
                 adaptor.addChild(root_0, root_1);
 5964  8
                 }
 5965  
 
 5966  8
             }
 5967  
 
 5968  8
 
 5969  32
             retval.tree = root_0;
 5970  
 
 5971  
             }
 5972  
 
 5973  32
             retval.stop = input.LT(-1);
 5974  8
 
 5975  
 
 5976  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5977  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5978  8
 
 5979  
         }
 5980  0
         catch (RecognitionException re) {
 5981  8
             reportError(re);
 5982  8
             recover(input,re);
 5983  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5984  
 
 5985  
         }
 5986  
 
 5987  0
         finally {
 5988  
                 // do for sure before leaving
 5989  32
         }
 5990  32
         return retval;
 5991  
     }
 5992  
     // $ANTLR end "clear"
 5993  
 
 5994  8
 
 5995  8
     public static class drop_return extends ParserRuleReturnScope {
 5996  
         Object tree;
 5997  32
         public Object getTree() { return tree; }
 5998  
     };
 5999  
 
 6000  8
 
 6001  
     // $ANTLR start "drop"
 6002  8
     // com\\googlecode\\sparkleg\\Sparql.g:222:1: drop : DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) ;
 6003  
     public final SparqlParser.drop_return drop() throws RecognitionException {
 6004  32
         SparqlParser.drop_return retval = new SparqlParser.drop_return();
 6005  32
         retval.start = input.LT(1);
 6006  
 
 6007  
 
 6008  32
         Object root_0 = null;
 6009  8
 
 6010  40
         Token DROP131=null;
 6011  32
         Token SILENT132=null;
 6012  32
         SparqlParser.graphRefAll_return graphRefAll133 =null;
 6013  8
 
 6014  
 
 6015  40
         Object DROP131_tree=null;
 6016  40
         Object SILENT132_tree=null;
 6017  40
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6018  32
         RewriteRuleTokenStream stream_DROP=new RewriteRuleTokenStream(adaptor,"token DROP");
 6019  32
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 6020  8
         try {
 6021  8
             // com\\googlecode\\sparkleg\\Sparql.g:223:5: ( DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) )
 6022  8
             // com\\googlecode\\sparkleg\\Sparql.g:223:7: DROP ( SILENT )? graphRefAll
 6023  8
             {
 6024  40
             DROP131=(Token)match(input,DROP,FOLLOW_DROP_in_drop1627);  
 6025  32
             stream_DROP.add(DROP131);
 6026  
 
 6027  
 
 6028  
             // com\\googlecode\\sparkleg\\Sparql.g:223:12: ( SILENT )?
 6029  40
             int alt45=2;
 6030  40
             switch ( input.LA(1) ) {
 6031  
                 case SILENT:
 6032  
                     {
 6033  0
                     alt45=1;
 6034  8
                     }
 6035  8
                     break;
 6036  
             }
 6037  
 
 6038  32
             switch (alt45) {
 6039  
                 case 1 :
 6040  
                     // com\\googlecode\\sparkleg\\Sparql.g:223:12: SILENT
 6041  
                     {
 6042  0
                     SILENT132=(Token)match(input,SILENT,FOLLOW_SILENT_in_drop1629);  
 6043  8
                     stream_SILENT.add(SILENT132);
 6044  
 
 6045  
 
 6046  
                     }
 6047  
                     break;
 6048  
 
 6049  
             }
 6050  
 
 6051  
 
 6052  32
             pushFollow(FOLLOW_graphRefAll_in_drop1632);
 6053  32
             graphRefAll133=graphRefAll();
 6054  
 
 6055  32
             state._fsp--;
 6056  
 
 6057  40
             stream_graphRefAll.add(graphRefAll133.getTree());
 6058  8
 
 6059  
             // AST REWRITE
 6060  8
             // elements: SILENT, graphRefAll, DROP
 6061  
             // token labels: 
 6062  8
             // rule labels: retval
 6063  
             // token list labels: 
 6064  
             // rule list labels: 
 6065  
             // wildcard labels: 
 6066  32
             retval.tree = root_0;
 6067  32
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6068  
 
 6069  32
             root_0 = (Object)adaptor.nil();
 6070  
             // 223:32: -> ^( DROP ( SILENT )* graphRefAll )
 6071  8
             {
 6072  8
                 // com\\googlecode\\sparkleg\\Sparql.g:223:35: ^( DROP ( SILENT )* graphRefAll )
 6073  
                 {
 6074  40
                 Object root_1 = (Object)adaptor.nil();
 6075  32
                 root_1 = (Object)adaptor.becomeRoot(
 6076  
                 stream_DROP.nextNode()
 6077  
                 , root_1);
 6078  
 
 6079  8
                 // com\\googlecode\\sparkleg\\Sparql.g:223:42: ( SILENT )*
 6080  40
                 while ( stream_SILENT.hasNext() ) {
 6081  0
                     adaptor.addChild(root_1, 
 6082  
                     stream_SILENT.nextNode()
 6083  
                     );
 6084  
 
 6085  8
                 }
 6086  32
                 stream_SILENT.reset();
 6087  
 
 6088  32
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 6089  
 
 6090  32
                 adaptor.addChild(root_0, root_1);
 6091  8
                 }
 6092  
 
 6093  8
             }
 6094  
 
 6095  8
 
 6096  32
             retval.tree = root_0;
 6097  
 
 6098  
             }
 6099  
 
 6100  32
             retval.stop = input.LT(-1);
 6101  8
 
 6102  
 
 6103  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6104  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6105  8
 
 6106  
         }
 6107  0
         catch (RecognitionException re) {
 6108  8
             reportError(re);
 6109  8
             recover(input,re);
 6110  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6111  
 
 6112  
         }
 6113  
 
 6114  0
         finally {
 6115  
                 // do for sure before leaving
 6116  32
         }
 6117  32
         return retval;
 6118  
     }
 6119  
     // $ANTLR end "drop"
 6120  
 
 6121  8
 
 6122  8
     public static class create_return extends ParserRuleReturnScope {
 6123  
         Object tree;
 6124  0
         public Object getTree() { return tree; }
 6125  
     };
 6126  
 
 6127  
 
 6128  
     // $ANTLR start "create"
 6129  
     // com\\googlecode\\sparkleg\\Sparql.g:226:1: create : CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) ;
 6130  
     public final SparqlParser.create_return create() throws RecognitionException {
 6131  0
         SparqlParser.create_return retval = new SparqlParser.create_return();
 6132  0
         retval.start = input.LT(1);
 6133  
 
 6134  
 
 6135  0
         Object root_0 = null;
 6136  
 
 6137  0
         Token CREATE134=null;
 6138  0
         Token SILENT135=null;
 6139  0
         SparqlParser.graphRef_return graphRef136 =null;
 6140  
 
 6141  
 
 6142  0
         Object CREATE134_tree=null;
 6143  0
         Object SILENT135_tree=null;
 6144  0
         RewriteRuleTokenStream stream_CREATE=new RewriteRuleTokenStream(adaptor,"token CREATE");
 6145  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6146  0
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 6147  
         try {
 6148  
             // com\\googlecode\\sparkleg\\Sparql.g:227:5: ( CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) )
 6149  
             // com\\googlecode\\sparkleg\\Sparql.g:227:7: CREATE ( SILENT )? graphRef
 6150  
             {
 6151  0
             CREATE134=(Token)match(input,CREATE,FOLLOW_CREATE_in_create1661);  
 6152  0
             stream_CREATE.add(CREATE134);
 6153  
 
 6154  
 
 6155  
             // com\\googlecode\\sparkleg\\Sparql.g:227:14: ( SILENT )?
 6156  0
             int alt46=2;
 6157  0
             switch ( input.LA(1) ) {
 6158  
                 case SILENT:
 6159  
                     {
 6160  0
                     alt46=1;
 6161  
                     }
 6162  
                     break;
 6163  
             }
 6164  
 
 6165  0
             switch (alt46) {
 6166  
                 case 1 :
 6167  
                     // com\\googlecode\\sparkleg\\Sparql.g:227:14: SILENT
 6168  
                     {
 6169  0
                     SILENT135=(Token)match(input,SILENT,FOLLOW_SILENT_in_create1663);  
 6170  0
                     stream_SILENT.add(SILENT135);
 6171  
 
 6172  
 
 6173  
                     }
 6174  
                     break;
 6175  
 
 6176  
             }
 6177  
 
 6178  
 
 6179  0
             pushFollow(FOLLOW_graphRef_in_create1666);
 6180  0
             graphRef136=graphRef();
 6181  
 
 6182  0
             state._fsp--;
 6183  
 
 6184  0
             stream_graphRef.add(graphRef136.getTree());
 6185  
 
 6186  
             // AST REWRITE
 6187  
             // elements: SILENT, graphRef, CREATE
 6188  
             // token labels: 
 6189  
             // rule labels: retval
 6190  
             // token list labels: 
 6191  
             // rule list labels: 
 6192  
             // wildcard labels: 
 6193  0
             retval.tree = root_0;
 6194  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6195  
 
 6196  0
             root_0 = (Object)adaptor.nil();
 6197  
             // 227:31: -> ^( CREATE ( SILENT )* graphRef )
 6198  
             {
 6199  
                 // com\\googlecode\\sparkleg\\Sparql.g:227:34: ^( CREATE ( SILENT )* graphRef )
 6200  
                 {
 6201  0
                 Object root_1 = (Object)adaptor.nil();
 6202  0
                 root_1 = (Object)adaptor.becomeRoot(
 6203  
                 stream_CREATE.nextNode()
 6204  
                 , root_1);
 6205  
 
 6206  
                 // com\\googlecode\\sparkleg\\Sparql.g:227:43: ( SILENT )*
 6207  0
                 while ( stream_SILENT.hasNext() ) {
 6208  0
                     adaptor.addChild(root_1, 
 6209  
                     stream_SILENT.nextNode()
 6210  
                     );
 6211  
 
 6212  
                 }
 6213  0
                 stream_SILENT.reset();
 6214  
 
 6215  0
                 adaptor.addChild(root_1, stream_graphRef.nextTree());
 6216  
 
 6217  0
                 adaptor.addChild(root_0, root_1);
 6218  
                 }
 6219  
 
 6220  
             }
 6221  
 
 6222  
 
 6223  0
             retval.tree = root_0;
 6224  
 
 6225  
             }
 6226  
 
 6227  0
             retval.stop = input.LT(-1);
 6228  
 
 6229  
 
 6230  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6231  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6232  
 
 6233  
         }
 6234  0
         catch (RecognitionException re) {
 6235  0
             reportError(re);
 6236  0
             recover(input,re);
 6237  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6238  
 
 6239  
         }
 6240  
 
 6241  0
         finally {
 6242  
                 // do for sure before leaving
 6243  0
         }
 6244  0
         return retval;
 6245  
     }
 6246  
     // $ANTLR end "create"
 6247  
 
 6248  
 
 6249  0
     public static class add_return extends ParserRuleReturnScope {
 6250  
         Object tree;
 6251  0
         public Object getTree() { return tree; }
 6252  
     };
 6253  
 
 6254  
 
 6255  
     // $ANTLR start "add"
 6256  
     // com\\googlecode\\sparkleg\\Sparql.g:230:1: add : ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) ;
 6257  
     public final SparqlParser.add_return add() throws RecognitionException {
 6258  0
         SparqlParser.add_return retval = new SparqlParser.add_return();
 6259  0
         retval.start = input.LT(1);
 6260  
 
 6261  
 
 6262  0
         Object root_0 = null;
 6263  
 
 6264  0
         Token ADD137=null;
 6265  0
         Token SILENT138=null;
 6266  0
         Token TO139=null;
 6267  0
         SparqlParser.graphOrDefault_return from =null;
 6268  
 
 6269  0
         SparqlParser.graphOrDefault_return to =null;
 6270  
 
 6271  
 
 6272  0
         Object ADD137_tree=null;
 6273  0
         Object SILENT138_tree=null;
 6274  0
         Object TO139_tree=null;
 6275  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6276  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6277  0
         RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
 6278  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6279  
         try {
 6280  
             // com\\googlecode\\sparkleg\\Sparql.g:231:5: ( ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) )
 6281  
             // com\\googlecode\\sparkleg\\Sparql.g:231:7: ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6282  
             {
 6283  0
             ADD137=(Token)match(input,ADD,FOLLOW_ADD_in_add1698);  
 6284  0
             stream_ADD.add(ADD137);
 6285  
 
 6286  
 
 6287  
             // com\\googlecode\\sparkleg\\Sparql.g:231:11: ( SILENT )?
 6288  0
             int alt47=2;
 6289  0
             switch ( input.LA(1) ) {
 6290  
                 case SILENT:
 6291  
                     {
 6292  0
                     alt47=1;
 6293  
                     }
 6294  
                     break;
 6295  
             }
 6296  
 
 6297  0
             switch (alt47) {
 6298  
                 case 1 :
 6299  
                     // com\\googlecode\\sparkleg\\Sparql.g:231:11: SILENT
 6300  
                     {
 6301  0
                     SILENT138=(Token)match(input,SILENT,FOLLOW_SILENT_in_add1700);  
 6302  0
                     stream_SILENT.add(SILENT138);
 6303  
 
 6304  
 
 6305  
                     }
 6306  
                     break;
 6307  
 
 6308  
             }
 6309  
 
 6310  
 
 6311  0
             pushFollow(FOLLOW_graphOrDefault_in_add1705);
 6312  0
             from=graphOrDefault();
 6313  
 
 6314  0
             state._fsp--;
 6315  
 
 6316  0
             stream_graphOrDefault.add(from.getTree());
 6317  
 
 6318  0
             TO139=(Token)match(input,TO,FOLLOW_TO_in_add1707);  
 6319  0
             stream_TO.add(TO139);
 6320  
 
 6321  
 
 6322  0
             pushFollow(FOLLOW_graphOrDefault_in_add1711);
 6323  0
             to=graphOrDefault();
 6324  
 
 6325  0
             state._fsp--;
 6326  
 
 6327  0
             stream_graphOrDefault.add(to.getTree());
 6328  
 
 6329  
             // AST REWRITE
 6330  
             // elements: from, to, ADD, SILENT
 6331  
             // token labels: 
 6332  
             // rule labels: to, retval, from
 6333  
             // token list labels: 
 6334  
             // rule list labels: 
 6335  
             // wildcard labels: 
 6336  0
             retval.tree = root_0;
 6337  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6338  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6339  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6340  
 
 6341  0
             root_0 = (Object)adaptor.nil();
 6342  
             // 231:60: -> ^( ADD ( SILENT )* $from $to)
 6343  
             {
 6344  
                 // com\\googlecode\\sparkleg\\Sparql.g:231:63: ^( ADD ( SILENT )* $from $to)
 6345  
                 {
 6346  0
                 Object root_1 = (Object)adaptor.nil();
 6347  0
                 root_1 = (Object)adaptor.becomeRoot(
 6348  
                 stream_ADD.nextNode()
 6349  
                 , root_1);
 6350  
 
 6351  
                 // com\\googlecode\\sparkleg\\Sparql.g:231:69: ( SILENT )*
 6352  0
                 while ( stream_SILENT.hasNext() ) {
 6353  0
                     adaptor.addChild(root_1, 
 6354  
                     stream_SILENT.nextNode()
 6355  
                     );
 6356  
 
 6357  
                 }
 6358  0
                 stream_SILENT.reset();
 6359  
 
 6360  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6361  
 
 6362  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6363  
 
 6364  0
                 adaptor.addChild(root_0, root_1);
 6365  
                 }
 6366  
 
 6367  
             }
 6368  
 
 6369  
 
 6370  0
             retval.tree = root_0;
 6371  
 
 6372  
             }
 6373  
 
 6374  0
             retval.stop = input.LT(-1);
 6375  
 
 6376  
 
 6377  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6378  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6379  
 
 6380  
         }
 6381  0
         catch (RecognitionException re) {
 6382  0
             reportError(re);
 6383  0
             recover(input,re);
 6384  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6385  
 
 6386  
         }
 6387  
 
 6388  0
         finally {
 6389  
                 // do for sure before leaving
 6390  0
         }
 6391  0
         return retval;
 6392  
     }
 6393  
     // $ANTLR end "add"
 6394  
 
 6395  
 
 6396  0
     public static class move_return extends ParserRuleReturnScope {
 6397  
         Object tree;
 6398  0
         public Object getTree() { return tree; }
 6399  
     };
 6400  
 
 6401  
 
 6402  
     // $ANTLR start "move"
 6403  
     // com\\googlecode\\sparkleg\\Sparql.g:234:1: move : MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) ;
 6404  
     public final SparqlParser.move_return move() throws RecognitionException {
 6405  0
         SparqlParser.move_return retval = new SparqlParser.move_return();
 6406  0
         retval.start = input.LT(1);
 6407  
 
 6408  
 
 6409  0
         Object root_0 = null;
 6410  
 
 6411  0
         Token MOVE140=null;
 6412  0
         Token SILENT141=null;
 6413  0
         Token TO142=null;
 6414  0
         SparqlParser.graphOrDefault_return from =null;
 6415  
 
 6416  0
         SparqlParser.graphOrDefault_return to =null;
 6417  
 
 6418  
 
 6419  0
         Object MOVE140_tree=null;
 6420  0
         Object SILENT141_tree=null;
 6421  0
         Object TO142_tree=null;
 6422  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6423  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6424  0
         RewriteRuleTokenStream stream_MOVE=new RewriteRuleTokenStream(adaptor,"token MOVE");
 6425  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6426  
         try {
 6427  
             // com\\googlecode\\sparkleg\\Sparql.g:235:5: ( MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) )
 6428  
             // com\\googlecode\\sparkleg\\Sparql.g:235:7: MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6429  
             {
 6430  0
             MOVE140=(Token)match(input,MOVE,FOLLOW_MOVE_in_move1747);  
 6431  0
             stream_MOVE.add(MOVE140);
 6432  
 
 6433  
 
 6434  
             // com\\googlecode\\sparkleg\\Sparql.g:235:12: ( SILENT )?
 6435  0
             int alt48=2;
 6436  0
             switch ( input.LA(1) ) {
 6437  
                 case SILENT:
 6438  
                     {
 6439  0
                     alt48=1;
 6440  
                     }
 6441  
                     break;
 6442  
             }
 6443  
 
 6444  0
             switch (alt48) {
 6445  
                 case 1 :
 6446  
                     // com\\googlecode\\sparkleg\\Sparql.g:235:12: SILENT
 6447  
                     {
 6448  0
                     SILENT141=(Token)match(input,SILENT,FOLLOW_SILENT_in_move1749);  
 6449  0
                     stream_SILENT.add(SILENT141);
 6450  
 
 6451  
 
 6452  
                     }
 6453  
                     break;
 6454  
 
 6455  
             }
 6456  
 
 6457  
 
 6458  0
             pushFollow(FOLLOW_graphOrDefault_in_move1754);
 6459  0
             from=graphOrDefault();
 6460  
 
 6461  0
             state._fsp--;
 6462  
 
 6463  0
             stream_graphOrDefault.add(from.getTree());
 6464  
 
 6465  0
             TO142=(Token)match(input,TO,FOLLOW_TO_in_move1756);  
 6466  0
             stream_TO.add(TO142);
 6467  
 
 6468  
 
 6469  0
             pushFollow(FOLLOW_graphOrDefault_in_move1760);
 6470  0
             to=graphOrDefault();
 6471  
 
 6472  0
             state._fsp--;
 6473  
 
 6474  0
             stream_graphOrDefault.add(to.getTree());
 6475  
 
 6476  
             // AST REWRITE
 6477  
             // elements: MOVE, to, SILENT, from
 6478  
             // token labels: 
 6479  
             // rule labels: to, retval, from
 6480  
             // token list labels: 
 6481  
             // rule list labels: 
 6482  
             // wildcard labels: 
 6483  0
             retval.tree = root_0;
 6484  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6485  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6486  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6487  
 
 6488  0
             root_0 = (Object)adaptor.nil();
 6489  
             // 235:61: -> ^( MOVE ( SILENT )* $from $to)
 6490  
             {
 6491  
                 // com\\googlecode\\sparkleg\\Sparql.g:235:64: ^( MOVE ( SILENT )* $from $to)
 6492  
                 {
 6493  0
                 Object root_1 = (Object)adaptor.nil();
 6494  0
                 root_1 = (Object)adaptor.becomeRoot(
 6495  
                 stream_MOVE.nextNode()
 6496  
                 , root_1);
 6497  
 
 6498  
                 // com\\googlecode\\sparkleg\\Sparql.g:235:71: ( SILENT )*
 6499  0
                 while ( stream_SILENT.hasNext() ) {
 6500  0
                     adaptor.addChild(root_1, 
 6501  
                     stream_SILENT.nextNode()
 6502  
                     );
 6503  
 
 6504  
                 }
 6505  0
                 stream_SILENT.reset();
 6506  
 
 6507  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6508  
 
 6509  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6510  
 
 6511  0
                 adaptor.addChild(root_0, root_1);
 6512  
                 }
 6513  
 
 6514  
             }
 6515  
 
 6516  
 
 6517  0
             retval.tree = root_0;
 6518  
 
 6519  
             }
 6520  
 
 6521  0
             retval.stop = input.LT(-1);
 6522  
 
 6523  
 
 6524  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6525  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6526  
 
 6527  
         }
 6528  0
         catch (RecognitionException re) {
 6529  0
             reportError(re);
 6530  0
             recover(input,re);
 6531  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6532  
 
 6533  
         }
 6534  
 
 6535  0
         finally {
 6536  
                 // do for sure before leaving
 6537  0
         }
 6538  0
         return retval;
 6539  
     }
 6540  
     // $ANTLR end "move"
 6541  
 
 6542  
 
 6543  0
     public static class copy_return extends ParserRuleReturnScope {
 6544  
         Object tree;
 6545  0
         public Object getTree() { return tree; }
 6546  
     };
 6547  
 
 6548  
 
 6549  
     // $ANTLR start "copy"
 6550  
     // com\\googlecode\\sparkleg\\Sparql.g:238:1: copy : COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) ;
 6551  
     public final SparqlParser.copy_return copy() throws RecognitionException {
 6552  0
         SparqlParser.copy_return retval = new SparqlParser.copy_return();
 6553  0
         retval.start = input.LT(1);
 6554  
 
 6555  
 
 6556  0
         Object root_0 = null;
 6557  
 
 6558  0
         Token COPY143=null;
 6559  0
         Token SILENT144=null;
 6560  0
         Token TO145=null;
 6561  0
         SparqlParser.graphOrDefault_return from =null;
 6562  
 
 6563  0
         SparqlParser.graphOrDefault_return to =null;
 6564  
 
 6565  
 
 6566  0
         Object COPY143_tree=null;
 6567  0
         Object SILENT144_tree=null;
 6568  0
         Object TO145_tree=null;
 6569  0
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6570  0
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6571  0
         RewriteRuleTokenStream stream_COPY=new RewriteRuleTokenStream(adaptor,"token COPY");
 6572  0
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6573  
         try {
 6574  
             // com\\googlecode\\sparkleg\\Sparql.g:239:5: ( COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) )
 6575  
             // com\\googlecode\\sparkleg\\Sparql.g:239:7: COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6576  
             {
 6577  0
             COPY143=(Token)match(input,COPY,FOLLOW_COPY_in_copy1796);  
 6578  0
             stream_COPY.add(COPY143);
 6579  
 
 6580  
 
 6581  
             // com\\googlecode\\sparkleg\\Sparql.g:239:12: ( SILENT )?
 6582  0
             int alt49=2;
 6583  0
             switch ( input.LA(1) ) {
 6584  
                 case SILENT:
 6585  
                     {
 6586  0
                     alt49=1;
 6587  
                     }
 6588  
                     break;
 6589  
             }
 6590  
 
 6591  0
             switch (alt49) {
 6592  
                 case 1 :
 6593  
                     // com\\googlecode\\sparkleg\\Sparql.g:239:12: SILENT
 6594  
                     {
 6595  0
                     SILENT144=(Token)match(input,SILENT,FOLLOW_SILENT_in_copy1798);  
 6596  0
                     stream_SILENT.add(SILENT144);
 6597  
 
 6598  
 
 6599  
                     }
 6600  
                     break;
 6601  
 
 6602  
             }
 6603  
 
 6604  
 
 6605  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1803);
 6606  0
             from=graphOrDefault();
 6607  
 
 6608  0
             state._fsp--;
 6609  
 
 6610  0
             stream_graphOrDefault.add(from.getTree());
 6611  
 
 6612  0
             TO145=(Token)match(input,TO,FOLLOW_TO_in_copy1805);  
 6613  0
             stream_TO.add(TO145);
 6614  
 
 6615  
 
 6616  0
             pushFollow(FOLLOW_graphOrDefault_in_copy1809);
 6617  0
             to=graphOrDefault();
 6618  
 
 6619  0
             state._fsp--;
 6620  
 
 6621  0
             stream_graphOrDefault.add(to.getTree());
 6622  
 
 6623  
             // AST REWRITE
 6624  
             // elements: COPY, to, from, SILENT
 6625  
             // token labels: 
 6626  
             // rule labels: to, retval, from
 6627  
             // token list labels: 
 6628  
             // rule list labels: 
 6629  
             // wildcard labels: 
 6630  0
             retval.tree = root_0;
 6631  0
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6632  0
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6633  0
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6634  
 
 6635  0
             root_0 = (Object)adaptor.nil();
 6636  
             // 239:61: -> ^( COPY ( SILENT )* $from $to)
 6637  
             {
 6638  
                 // com\\googlecode\\sparkleg\\Sparql.g:239:64: ^( COPY ( SILENT )* $from $to)
 6639  
                 {
 6640  0
                 Object root_1 = (Object)adaptor.nil();
 6641  0
                 root_1 = (Object)adaptor.becomeRoot(
 6642  
                 stream_COPY.nextNode()
 6643  
                 , root_1);
 6644  
 
 6645  
                 // com\\googlecode\\sparkleg\\Sparql.g:239:71: ( SILENT )*
 6646  0
                 while ( stream_SILENT.hasNext() ) {
 6647  0
                     adaptor.addChild(root_1, 
 6648  
                     stream_SILENT.nextNode()
 6649  
                     );
 6650  
 
 6651  
                 }
 6652  0
                 stream_SILENT.reset();
 6653  
 
 6654  0
                 adaptor.addChild(root_1, stream_from.nextTree());
 6655  
 
 6656  0
                 adaptor.addChild(root_1, stream_to.nextTree());
 6657  
 
 6658  0
                 adaptor.addChild(root_0, root_1);
 6659  
                 }
 6660  
 
 6661  
             }
 6662  
 
 6663  
 
 6664  0
             retval.tree = root_0;
 6665  
 
 6666  
             }
 6667  
 
 6668  0
             retval.stop = input.LT(-1);
 6669  
 
 6670  
 
 6671  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6672  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6673  
 
 6674  
         }
 6675  0
         catch (RecognitionException re) {
 6676  0
             reportError(re);
 6677  0
             recover(input,re);
 6678  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6679  
 
 6680  
         }
 6681  
 
 6682  0
         finally {
 6683  
                 // do for sure before leaving
 6684  0
         }
 6685  0
         return retval;
 6686  
     }
 6687  
     // $ANTLR end "copy"
 6688  
 
 6689  
 
 6690  32
     public static class insert_return extends ParserRuleReturnScope {
 6691  
         Object tree;
 6692  32
         public Object getTree() { return tree; }
 6693  
     };
 6694  
 
 6695  8
 
 6696  
     // $ANTLR start "insert"
 6697  8
     // com\\googlecode\\sparkleg\\Sparql.g:242:1: insert : INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) ;
 6698  
     public final SparqlParser.insert_return insert() throws RecognitionException {
 6699  32
         SparqlParser.insert_return retval = new SparqlParser.insert_return();
 6700  32
         retval.start = input.LT(1);
 6701  
 
 6702  
 
 6703  32
         Object root_0 = null;
 6704  8
 
 6705  40
         Token INSERT146=null;
 6706  32
         Token DATA147=null;
 6707  32
         SparqlParser.quadPattern_return quadPattern148 =null;
 6708  8
 
 6709  
 
 6710  40
         Object INSERT146_tree=null;
 6711  40
         Object DATA147_tree=null;
 6712  40
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 6713  32
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6714  32
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6715  8
         try {
 6716  8
             // com\\googlecode\\sparkleg\\Sparql.g:243:5: ( INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) )
 6717  8
             // com\\googlecode\\sparkleg\\Sparql.g:243:7: INSERT DATA quadPattern
 6718  8
             {
 6719  40
             INSERT146=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1841);  
 6720  32
             stream_INSERT.add(INSERT146);
 6721  
 
 6722  
 
 6723  32
             DATA147=(Token)match(input,DATA,FOLLOW_DATA_in_insert1843);  
 6724  40
             stream_DATA.add(DATA147);
 6725  8
 
 6726  
 
 6727  32
             pushFollow(FOLLOW_quadPattern_in_insert1845);
 6728  40
             quadPattern148=quadPattern();
 6729  8
 
 6730  32
             state._fsp--;
 6731  
 
 6732  40
             stream_quadPattern.add(quadPattern148.getTree());
 6733  8
 
 6734  
             // AST REWRITE
 6735  8
             // elements: quadPattern, INSERT, DATA
 6736  
             // token labels: 
 6737  8
             // rule labels: retval
 6738  
             // token list labels: 
 6739  
             // rule list labels: 
 6740  
             // wildcard labels: 
 6741  32
             retval.tree = root_0;
 6742  32
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6743  
 
 6744  32
             root_0 = (Object)adaptor.nil();
 6745  
             // 243:31: -> ^( INSERT DATA quadPattern )
 6746  8
             {
 6747  8
                 // com\\googlecode\\sparkleg\\Sparql.g:243:34: ^( INSERT DATA quadPattern )
 6748  
                 {
 6749  40
                 Object root_1 = (Object)adaptor.nil();
 6750  32
                 root_1 = (Object)adaptor.becomeRoot(
 6751  
                 stream_INSERT.nextNode()
 6752  
                 , root_1);
 6753  
 
 6754  40
                 adaptor.addChild(root_1, 
 6755  8
                 stream_DATA.nextNode()
 6756  
                 );
 6757  
 
 6758  32
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6759  8
 
 6760  32
                 adaptor.addChild(root_0, root_1);
 6761  
                 }
 6762  
 
 6763  8
             }
 6764  
 
 6765  8
 
 6766  32
             retval.tree = root_0;
 6767  
 
 6768  
             }
 6769  
 
 6770  32
             retval.stop = input.LT(-1);
 6771  8
 
 6772  
 
 6773  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6774  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6775  8
 
 6776  
         }
 6777  0
         catch (RecognitionException re) {
 6778  8
             reportError(re);
 6779  8
             recover(input,re);
 6780  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6781  
 
 6782  
         }
 6783  
 
 6784  0
         finally {
 6785  
                 // do for sure before leaving
 6786  32
         }
 6787  32
         return retval;
 6788  
     }
 6789  
     // $ANTLR end "insert"
 6790  
 
 6791  8
 
 6792  8
     public static class delete_return extends ParserRuleReturnScope {
 6793  
         Object tree;
 6794  96
         public Object getTree() { return tree; }
 6795  
     };
 6796  
 
 6797  24
 
 6798  
     // $ANTLR start "delete"
 6799  24
     // com\\googlecode\\sparkleg\\Sparql.g:246:1: delete : ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) );
 6800  
     public final SparqlParser.delete_return delete() throws RecognitionException {
 6801  96
         SparqlParser.delete_return retval = new SparqlParser.delete_return();
 6802  96
         retval.start = input.LT(1);
 6803  
 
 6804  
 
 6805  96
         Object root_0 = null;
 6806  24
 
 6807  120
         Token DELETE149=null;
 6808  96
         Token DELETE151=null;
 6809  96
         SparqlParser.deleteData_return deleteData150 =null;
 6810  24
 
 6811  96
         SparqlParser.deleteWhere_return deleteWhere152 =null;
 6812  24
 
 6813  24
 
 6814  120
         Object DELETE149_tree=null;
 6815  96
         Object DELETE151_tree=null;
 6816  120
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 6817  96
         RewriteRuleSubtreeStream stream_deleteData=new RewriteRuleSubtreeStream(adaptor,"rule deleteData");
 6818  96
         RewriteRuleSubtreeStream stream_deleteWhere=new RewriteRuleSubtreeStream(adaptor,"rule deleteWhere");
 6819  24
         try {
 6820  24
             // com\\googlecode\\sparkleg\\Sparql.g:247:5: ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) )
 6821  120
             int alt50=2;
 6822  120
             switch ( input.LA(1) ) {
 6823  24
             case DELETE:
 6824  
                 {
 6825  96
                 switch ( input.LA(2) ) {
 6826  24
                 case DATA:
 6827  24
                     {
 6828  48
                     alt50=1;
 6829  
                     }
 6830  72
                     break;
 6831  
                 case WHERE:
 6832  
                     {
 6833  60
                     alt50=2;
 6834  
                     }
 6835  60
                     break;
 6836  
                 default:
 6837  0
                     NoViableAltException nvae =
 6838  12
                         new NoViableAltException("", 50, 1, input);
 6839  
 
 6840  12
                     throw nvae;
 6841  
 
 6842  
                 }
 6843  
 
 6844  
                 }
 6845  96
                 break;
 6846  
             default:
 6847  0
                 NoViableAltException nvae =
 6848  
                     new NoViableAltException("", 50, 0, input);
 6849  
 
 6850  24
                 throw nvae;
 6851  
 
 6852  
             }
 6853  
 
 6854  96
             switch (alt50) {
 6855  
                 case 1 :
 6856  
                     // com\\googlecode\\sparkleg\\Sparql.g:247:7: DELETE deleteData
 6857  
                     {
 6858  48
                     DELETE149=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1879);  
 6859  72
                     stream_DELETE.add(DELETE149);
 6860  
 
 6861  
 
 6862  48
                     pushFollow(FOLLOW_deleteData_in_delete1881);
 6863  60
                     deleteData150=deleteData();
 6864  12
 
 6865  48
                     state._fsp--;
 6866  
 
 6867  60
                     stream_deleteData.add(deleteData150.getTree());
 6868  12
 
 6869  
                     // AST REWRITE
 6870  12
                     // elements: DELETE, deleteData
 6871  
                     // token labels: 
 6872  12
                     // rule labels: retval
 6873  
                     // token list labels: 
 6874  
                     // rule list labels: 
 6875  
                     // wildcard labels: 
 6876  48
                     retval.tree = root_0;
 6877  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6878  
 
 6879  48
                     root_0 = (Object)adaptor.nil();
 6880  
                     // 247:25: -> ^( DELETE deleteData )
 6881  12
                     {
 6882  12
                         // com\\googlecode\\sparkleg\\Sparql.g:247:28: ^( DELETE deleteData )
 6883  
                         {
 6884  60
                         Object root_1 = (Object)adaptor.nil();
 6885  48
                         root_1 = (Object)adaptor.becomeRoot(
 6886  
                         stream_DELETE.nextNode()
 6887  
                         , root_1);
 6888  
 
 6889  60
                         adaptor.addChild(root_1, stream_deleteData.nextTree());
 6890  12
 
 6891  48
                         adaptor.addChild(root_0, root_1);
 6892  
                         }
 6893  
 
 6894  12
                     }
 6895  
 
 6896  12
 
 6897  48
                     retval.tree = root_0;
 6898  
 
 6899  
                     }
 6900  48
                     break;
 6901  
                 case 2 :
 6902  12
                     // com\\googlecode\\sparkleg\\Sparql.g:248:7: DELETE deleteWhere
 6903  
                     {
 6904  48
                     DELETE151=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1897);  
 6905  60
                     stream_DELETE.add(DELETE151);
 6906  
 
 6907  
 
 6908  48
                     pushFollow(FOLLOW_deleteWhere_in_delete1899);
 6909  60
                     deleteWhere152=deleteWhere();
 6910  12
 
 6911  48
                     state._fsp--;
 6912  
 
 6913  60
                     stream_deleteWhere.add(deleteWhere152.getTree());
 6914  12
 
 6915  
                     // AST REWRITE
 6916  12
                     // elements: deleteWhere, DELETE
 6917  
                     // token labels: 
 6918  12
                     // rule labels: retval
 6919  
                     // token list labels: 
 6920  
                     // rule list labels: 
 6921  
                     // wildcard labels: 
 6922  48
                     retval.tree = root_0;
 6923  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6924  
 
 6925  48
                     root_0 = (Object)adaptor.nil();
 6926  
                     // 248:26: -> ^( DELETE deleteWhere )
 6927  12
                     {
 6928  12
                         // com\\googlecode\\sparkleg\\Sparql.g:248:29: ^( DELETE deleteWhere )
 6929  
                         {
 6930  60
                         Object root_1 = (Object)adaptor.nil();
 6931  48
                         root_1 = (Object)adaptor.becomeRoot(
 6932  
                         stream_DELETE.nextNode()
 6933  
                         , root_1);
 6934  
 
 6935  60
                         adaptor.addChild(root_1, stream_deleteWhere.nextTree());
 6936  12
 
 6937  48
                         adaptor.addChild(root_0, root_1);
 6938  
                         }
 6939  
 
 6940  12
                     }
 6941  
 
 6942  12
 
 6943  48
                     retval.tree = root_0;
 6944  
 
 6945  
                     }
 6946  
                     break;
 6947  
 
 6948  12
             }
 6949  96
             retval.stop = input.LT(-1);
 6950  
 
 6951  
 
 6952  96
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6953  96
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6954  24
 
 6955  
         }
 6956  0
         catch (RecognitionException re) {
 6957  24
             reportError(re);
 6958  24
             recover(input,re);
 6959  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6960  
 
 6961  
         }
 6962  
 
 6963  0
         finally {
 6964  
                 // do for sure before leaving
 6965  96
         }
 6966  96
         return retval;
 6967  
     }
 6968  
     // $ANTLR end "delete"
 6969  
 
 6970  24
 
 6971  24
     public static class deleteData_return extends ParserRuleReturnScope {
 6972  
         Object tree;
 6973  48
         public Object getTree() { return tree; }
 6974  
     };
 6975  
 
 6976  12
 
 6977  
     // $ANTLR start "deleteData"
 6978  12
     // com\\googlecode\\sparkleg\\Sparql.g:251:1: deleteData : DATA quadPattern -> ^( DELETE DATA quadPattern ) ;
 6979  
     public final SparqlParser.deleteData_return deleteData() throws RecognitionException {
 6980  48
         SparqlParser.deleteData_return retval = new SparqlParser.deleteData_return();
 6981  48
         retval.start = input.LT(1);
 6982  
 
 6983  
 
 6984  48
         Object root_0 = null;
 6985  12
 
 6986  60
         Token DATA153=null;
 6987  48
         SparqlParser.quadPattern_return quadPattern154 =null;
 6988  
 
 6989  12
 
 6990  48
         Object DATA153_tree=null;
 6991  60
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6992  60
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6993  
         try {
 6994  
             // com\\googlecode\\sparkleg\\Sparql.g:252:5: ( DATA quadPattern -> ^( DELETE DATA quadPattern ) )
 6995  12
             // com\\googlecode\\sparkleg\\Sparql.g:252:7: DATA quadPattern
 6996  12
             {
 6997  60
             DATA153=(Token)match(input,DATA,FOLLOW_DATA_in_deleteData1924);  
 6998  48
             stream_DATA.add(DATA153);
 6999  
 
 7000  
 
 7001  48
             pushFollow(FOLLOW_quadPattern_in_deleteData1926);
 7002  60
             quadPattern154=quadPattern();
 7003  12
 
 7004  48
             state._fsp--;
 7005  
 
 7006  60
             stream_quadPattern.add(quadPattern154.getTree());
 7007  12
 
 7008  
             // AST REWRITE
 7009  12
             // elements: quadPattern, DATA
 7010  
             // token labels: 
 7011  12
             // rule labels: retval
 7012  
             // token list labels: 
 7013  
             // rule list labels: 
 7014  
             // wildcard labels: 
 7015  48
             retval.tree = root_0;
 7016  48
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7017  
 
 7018  48
             root_0 = (Object)adaptor.nil();
 7019  
             // 252:24: -> ^( DELETE DATA quadPattern )
 7020  12
             {
 7021  12
                 // com\\googlecode\\sparkleg\\Sparql.g:252:27: ^( DELETE DATA quadPattern )
 7022  
                 {
 7023  60
                 Object root_1 = (Object)adaptor.nil();
 7024  48
                 root_1 = (Object)adaptor.becomeRoot(
 7025  
                 (Object)adaptor.create(DELETE, "DELETE")
 7026  
                 , root_1);
 7027  
 
 7028  60
                 adaptor.addChild(root_1, 
 7029  12
                 stream_DATA.nextNode()
 7030  
                 );
 7031  
 
 7032  48
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7033  12
 
 7034  48
                 adaptor.addChild(root_0, root_1);
 7035  
                 }
 7036  
 
 7037  12
             }
 7038  
 
 7039  12
 
 7040  48
             retval.tree = root_0;
 7041  
 
 7042  
             }
 7043  
 
 7044  48
             retval.stop = input.LT(-1);
 7045  12
 
 7046  
 
 7047  48
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7048  48
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7049  12
 
 7050  
         }
 7051  0
         catch (RecognitionException re) {
 7052  12
             reportError(re);
 7053  12
             recover(input,re);
 7054  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7055  
 
 7056  
         }
 7057  
 
 7058  0
         finally {
 7059  
                 // do for sure before leaving
 7060  48
         }
 7061  48
         return retval;
 7062  
     }
 7063  
     // $ANTLR end "deleteData"
 7064  
 
 7065  12
 
 7066  12
     public static class deleteWhere_return extends ParserRuleReturnScope {
 7067  
         Object tree;
 7068  48
         public Object getTree() { return tree; }
 7069  
     };
 7070  
 
 7071  12
 
 7072  
     // $ANTLR start "deleteWhere"
 7073  12
     // com\\googlecode\\sparkleg\\Sparql.g:255:1: deleteWhere : WHERE quadPattern -> ^( DELETE WHERE quadPattern ) ;
 7074  
     public final SparqlParser.deleteWhere_return deleteWhere() throws RecognitionException {
 7075  48
         SparqlParser.deleteWhere_return retval = new SparqlParser.deleteWhere_return();
 7076  48
         retval.start = input.LT(1);
 7077  
 
 7078  
 
 7079  48
         Object root_0 = null;
 7080  12
 
 7081  60
         Token WHERE155=null;
 7082  48
         SparqlParser.quadPattern_return quadPattern156 =null;
 7083  
 
 7084  12
 
 7085  48
         Object WHERE155_tree=null;
 7086  60
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7087  60
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7088  
         try {
 7089  
             // com\\googlecode\\sparkleg\\Sparql.g:256:5: ( WHERE quadPattern -> ^( DELETE WHERE quadPattern ) )
 7090  12
             // com\\googlecode\\sparkleg\\Sparql.g:256:7: WHERE quadPattern
 7091  12
             {
 7092  60
             WHERE155=(Token)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1953);  
 7093  48
             stream_WHERE.add(WHERE155);
 7094  
 
 7095  
 
 7096  48
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1955);
 7097  60
             quadPattern156=quadPattern();
 7098  12
 
 7099  48
             state._fsp--;
 7100  
 
 7101  60
             stream_quadPattern.add(quadPattern156.getTree());
 7102  12
 
 7103  
             // AST REWRITE
 7104  12
             // elements: quadPattern, WHERE
 7105  
             // token labels: 
 7106  12
             // rule labels: retval
 7107  
             // token list labels: 
 7108  
             // rule list labels: 
 7109  
             // wildcard labels: 
 7110  48
             retval.tree = root_0;
 7111  48
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7112  
 
 7113  48
             root_0 = (Object)adaptor.nil();
 7114  
             // 256:25: -> ^( DELETE WHERE quadPattern )
 7115  12
             {
 7116  12
                 // com\\googlecode\\sparkleg\\Sparql.g:256:28: ^( DELETE WHERE quadPattern )
 7117  
                 {
 7118  60
                 Object root_1 = (Object)adaptor.nil();
 7119  48
                 root_1 = (Object)adaptor.becomeRoot(
 7120  
                 (Object)adaptor.create(DELETE, "DELETE")
 7121  
                 , root_1);
 7122  
 
 7123  60
                 adaptor.addChild(root_1, 
 7124  12
                 stream_WHERE.nextNode()
 7125  
                 );
 7126  
 
 7127  48
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7128  12
 
 7129  48
                 adaptor.addChild(root_0, root_1);
 7130  
                 }
 7131  
 
 7132  12
             }
 7133  
 
 7134  12
 
 7135  48
             retval.tree = root_0;
 7136  
 
 7137  
             }
 7138  
 
 7139  48
             retval.stop = input.LT(-1);
 7140  12
 
 7141  
 
 7142  48
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7143  48
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7144  12
 
 7145  
         }
 7146  0
         catch (RecognitionException re) {
 7147  12
             reportError(re);
 7148  12
             recover(input,re);
 7149  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7150  
 
 7151  
         }
 7152  
 
 7153  0
         finally {
 7154  
                 // do for sure before leaving
 7155  48
         }
 7156  48
         return retval;
 7157  
     }
 7158  
     // $ANTLR end "deleteWhere"
 7159  
 
 7160  12
 
 7161  12
     public static class modify_return extends ParserRuleReturnScope {
 7162  
         Object tree;
 7163  320
         public Object getTree() { return tree; }
 7164  
     };
 7165  
 
 7166  80
 
 7167  
     // $ANTLR start "modify"
 7168  80
     // com\\googlecode\\sparkleg\\Sparql.g:259:1: modify : ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) ;
 7169  
     public final SparqlParser.modify_return modify() throws RecognitionException {
 7170  320
         SparqlParser.modify_return retval = new SparqlParser.modify_return();
 7171  320
         retval.start = input.LT(1);
 7172  
 
 7173  
 
 7174  320
         Object root_0 = null;
 7175  80
 
 7176  400
         Token WITH157=null;
 7177  320
         Token WHERE163=null;
 7178  320
         SparqlParser.iriRef_return iriRef158 =null;
 7179  80
 
 7180  320
         SparqlParser.deleteClause_return deleteClause159 =null;
 7181  80
 
 7182  400
         SparqlParser.insertClause_return insertClause160 =null;
 7183  80
 
 7184  320
         SparqlParser.insertClause_return insertClause161 =null;
 7185  80
 
 7186  320
         SparqlParser.usingClause_return usingClause162 =null;
 7187  80
 
 7188  320
         SparqlParser.groupGraphPattern_return groupGraphPattern164 =null;
 7189  80
 
 7190  
 
 7191  400
         Object WITH157_tree=null;
 7192  320
         Object WHERE163_tree=null;
 7193  400
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7194  320
         RewriteRuleTokenStream stream_WITH=new RewriteRuleTokenStream(adaptor,"token WITH");
 7195  320
         RewriteRuleSubtreeStream stream_deleteClause=new RewriteRuleSubtreeStream(adaptor,"rule deleteClause");
 7196  400
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 7197  400
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7198  400
         RewriteRuleSubtreeStream stream_insertClause=new RewriteRuleSubtreeStream(adaptor,"rule insertClause");
 7199  400
         RewriteRuleSubtreeStream stream_usingClause=new RewriteRuleSubtreeStream(adaptor,"rule usingClause");
 7200  80
         try {
 7201  80
             // com\\googlecode\\sparkleg\\Sparql.g:260:5: ( ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) )
 7202  80
             // com\\googlecode\\sparkleg\\Sparql.g:260:7: ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern
 7203  80
             {
 7204  80
             // com\\googlecode\\sparkleg\\Sparql.g:260:7: ( WITH iriRef )?
 7205  320
             int alt51=2;
 7206  320
             switch ( input.LA(1) ) {
 7207  
                 case WITH:
 7208  
                     {
 7209  56
                     alt51=1;
 7210  80
                     }
 7211  80
                     break;
 7212  
             }
 7213  
 
 7214  334
             switch (alt51) {
 7215  
                 case 1 :
 7216  
                     // com\\googlecode\\sparkleg\\Sparql.g:260:8: WITH iriRef
 7217  
                     {
 7218  56
                     WITH157=(Token)match(input,WITH,FOLLOW_WITH_in_modify1987);  
 7219  136
                     stream_WITH.add(WITH157);
 7220  
 
 7221  
 
 7222  56
                     pushFollow(FOLLOW_iriRef_in_modify1989);
 7223  70
                     iriRef158=iriRef();
 7224  14
 
 7225  56
                     state._fsp--;
 7226  
 
 7227  70
                     stream_iriRef.add(iriRef158.getTree());
 7228  14
 
 7229  
                     }
 7230  14
                     break;
 7231  
 
 7232  14
             }
 7233  
 
 7234  
 
 7235  
             // com\\googlecode\\sparkleg\\Sparql.g:260:22: ( deleteClause ( insertClause )? | insertClause )
 7236  320
             int alt53=2;
 7237  320
             switch ( input.LA(1) ) {
 7238  
             case DELETE:
 7239  
                 {
 7240  264
                 alt53=1;
 7241  80
                 }
 7242  344
                 break;
 7243  
             case INSERT:
 7244  
                 {
 7245  122
                 alt53=2;
 7246  
                 }
 7247  122
                 break;
 7248  
             default:
 7249  0
                 NoViableAltException nvae =
 7250  14
                     new NoViableAltException("", 53, 0, input);
 7251  
 
 7252  14
                 throw nvae;
 7253  
 
 7254  
             }
 7255  
 
 7256  320
             switch (alt53) {
 7257  
                 case 1 :
 7258  
                     // com\\googlecode\\sparkleg\\Sparql.g:260:23: deleteClause ( insertClause )?
 7259  
                     {
 7260  264
                     pushFollow(FOLLOW_deleteClause_in_modify1994);
 7261  344
                     deleteClause159=deleteClause();
 7262  
 
 7263  264
                     state._fsp--;
 7264  
 
 7265  330
                     stream_deleteClause.add(deleteClause159.getTree());
 7266  66
 
 7267  
                     // com\\googlecode\\sparkleg\\Sparql.g:260:36: ( insertClause )?
 7268  330
                     int alt52=2;
 7269  264
                     switch ( input.LA(1) ) {
 7270  66
                         case INSERT:
 7271  
                             {
 7272  40
                             alt52=1;
 7273  66
                             }
 7274  66
                             break;
 7275  
                     }
 7276  
 
 7277  274
                     switch (alt52) {
 7278  
                         case 1 :
 7279  
                             // com\\googlecode\\sparkleg\\Sparql.g:260:36: insertClause
 7280  
                             {
 7281  40
                             pushFollow(FOLLOW_insertClause_in_modify1996);
 7282  106
                             insertClause160=insertClause();
 7283  
 
 7284  40
                             state._fsp--;
 7285  
 
 7286  50
                             stream_insertClause.add(insertClause160.getTree());
 7287  10
 
 7288  
                             }
 7289  10
                             break;
 7290  
 
 7291  10
                     }
 7292  
 
 7293  
 
 7294  
                     }
 7295  264
                     break;
 7296  
                 case 2 :
 7297  
                     // com\\googlecode\\sparkleg\\Sparql.g:260:52: insertClause
 7298  
                     {
 7299  56
                     pushFollow(FOLLOW_insertClause_in_modify2001);
 7300  122
                     insertClause161=insertClause();
 7301  
 
 7302  56
                     state._fsp--;
 7303  
 
 7304  70
                     stream_insertClause.add(insertClause161.getTree());
 7305  14
 
 7306  
                     }
 7307  14
                     break;
 7308  
 
 7309  14
             }
 7310  
 
 7311  
 
 7312  
             // com\\googlecode\\sparkleg\\Sparql.g:260:66: ( usingClause )*
 7313  
             loop54:
 7314  
             do {
 7315  383
                 int alt54=2;
 7316  383
                 switch ( input.LA(1) ) {
 7317  
                 case USING:
 7318  
                     {
 7319  63
                     alt54=1;
 7320  98
                     }
 7321  98
                     break;
 7322  
 
 7323  
                 }
 7324  18
 
 7325  383
                 switch (alt54) {
 7326  
                     case 1 :
 7327  
                         // com\\googlecode\\sparkleg\\Sparql.g:260:66: usingClause
 7328  
                         {
 7329  63
                         pushFollow(FOLLOW_usingClause_in_modify2004);
 7330  161
                         usingClause162=usingClause();
 7331  
 
 7332  63
                         state._fsp--;
 7333  
 
 7334  81
                         stream_usingClause.add(usingClause162.getTree());
 7335  18
 
 7336  
                         }
 7337  81
                         break;
 7338  
 
 7339  18
                     default :
 7340  320
                         break loop54;
 7341  
                 }
 7342  81
             } while (true);
 7343  
 
 7344  
 
 7345  400
             WHERE163=(Token)match(input,WHERE,FOLLOW_WHERE_in_modify2007);  
 7346  320
             stream_WHERE.add(WHERE163);
 7347  18
 
 7348  
 
 7349  320
             pushFollow(FOLLOW_groupGraphPattern_in_modify2009);
 7350  400
             groupGraphPattern164=groupGraphPattern();
 7351  80
 
 7352  320
             state._fsp--;
 7353  
 
 7354  400
             stream_groupGraphPattern.add(groupGraphPattern164.getTree());
 7355  80
 
 7356  
             // AST REWRITE
 7357  80
             // elements: deleteClause, insertClause, WITH, groupGraphPattern, iriRef, usingClause
 7358  
             // token labels: 
 7359  80
             // rule labels: retval
 7360  
             // token list labels: 
 7361  
             // rule list labels: 
 7362  
             // wildcard labels: 
 7363  320
             retval.tree = root_0;
 7364  320
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7365  
 
 7366  320
             root_0 = (Object)adaptor.nil();
 7367  
             // 260:103: -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7368  80
             {
 7369  80
                 // com\\googlecode\\sparkleg\\Sparql.g:260:106: ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7370  
                 {
 7371  400
                 Object root_1 = (Object)adaptor.nil();
 7372  320
                 root_1 = (Object)adaptor.becomeRoot(
 7373  
                 (Object)adaptor.create(MODIFY, "MODIFY")
 7374  
                 , root_1);
 7375  
 
 7376  80
                 // com\\googlecode\\sparkleg\\Sparql.g:260:115: ( WITH iriRef )?
 7377  400
                 if ( stream_WITH.hasNext()||stream_iriRef.hasNext() ) {
 7378  56
                     adaptor.addChild(root_1, 
 7379  
                     stream_WITH.nextNode()
 7380  
                     );
 7381  
 
 7382  136
                     adaptor.addChild(root_1, stream_iriRef.nextTree());
 7383  
 
 7384  
                 }
 7385  334
                 stream_WITH.reset();
 7386  334
                 stream_iriRef.reset();
 7387  
 
 7388  
                 // com\\googlecode\\sparkleg\\Sparql.g:260:130: ( deleteClause )*
 7389  584
                 while ( stream_deleteClause.hasNext() ) {
 7390  278
                     adaptor.addChild(root_1, stream_deleteClause.nextTree());
 7391  
 
 7392  14
                 }
 7393  320
                 stream_deleteClause.reset();
 7394  
 
 7395  
                 // com\\googlecode\\sparkleg\\Sparql.g:260:144: ( insertClause )*
 7396  496
                 while ( stream_insertClause.hasNext() ) {
 7397  176
                     adaptor.addChild(root_1, stream_insertClause.nextTree());
 7398  
 
 7399  
                 }
 7400  466
                 stream_insertClause.reset();
 7401  66
 
 7402  
                 // com\\googlecode\\sparkleg\\Sparql.g:260:158: ( usingClause )*
 7403  383
                 while ( stream_usingClause.hasNext() ) {
 7404  143
                     adaptor.addChild(root_1, stream_usingClause.nextTree());
 7405  
 
 7406  
                 }
 7407  424
                 stream_usingClause.reset();
 7408  24
 
 7409  
                 // com\\googlecode\\sparkleg\\Sparql.g:260:171: ^( WHERE_CLAUSE groupGraphPattern )
 7410  
                 {
 7411  400
                 Object root_2 = (Object)adaptor.nil();
 7412  320
                 root_2 = (Object)adaptor.becomeRoot(
 7413  
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 7414  98
                 , root_2);
 7415  18
 
 7416  320
                 adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 7417  
 
 7418  400
                 adaptor.addChild(root_1, root_2);
 7419  
                 }
 7420  
 
 7421  320
                 adaptor.addChild(root_0, root_1);
 7422  80
                 }
 7423  80
 
 7424  
             }
 7425  
 
 7426  
 
 7427  400
             retval.tree = root_0;
 7428  
 
 7429  80
             }
 7430  
 
 7431  320
             retval.stop = input.LT(-1);
 7432  80
 
 7433  
 
 7434  320
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7435  320
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7436  
 
 7437  
         }
 7438  80
         catch (RecognitionException re) {
 7439  0
             reportError(re);
 7440  0
             recover(input,re);
 7441  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7442  80
 
 7443  
         }
 7444  
 
 7445  80
         finally {
 7446  80
                 // do for sure before leaving
 7447  320
         }
 7448  320
         return retval;
 7449  
     }
 7450  
     // $ANTLR end "modify"
 7451  
 
 7452  
 
 7453  264
     public static class deleteClause_return extends ParserRuleReturnScope {
 7454  
         Object tree;
 7455  264
         public Object getTree() { return tree; }
 7456  
     };
 7457  
 
 7458  80
 
 7459  80
     // $ANTLR start "deleteClause"
 7460  
     // com\\googlecode\\sparkleg\\Sparql.g:263:1: deleteClause : DELETE quadPattern -> ^( DELETE quadPattern ) ;
 7461  
     public final SparqlParser.deleteClause_return deleteClause() throws RecognitionException {
 7462  264
         SparqlParser.deleteClause_return retval = new SparqlParser.deleteClause_return();
 7463  264
         retval.start = input.LT(1);
 7464  66
 
 7465  
 
 7466  264
         Object root_0 = null;
 7467  
 
 7468  264
         Token DELETE165=null;
 7469  264
         SparqlParser.quadPattern_return quadPattern166 =null;
 7470  
 
 7471  
 
 7472  264
         Object DELETE165_tree=null;
 7473  330
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 7474  330
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7475  
         try {
 7476  
             // com\\googlecode\\sparkleg\\Sparql.g:264:5: ( DELETE quadPattern -> ^( DELETE quadPattern ) )
 7477  66
             // com\\googlecode\\sparkleg\\Sparql.g:264:7: DELETE quadPattern
 7478  
             {
 7479  330
             DELETE165=(Token)match(input,DELETE,FOLLOW_DELETE_in_deleteClause2056);  
 7480  330
             stream_DELETE.add(DELETE165);
 7481  
 
 7482  
 
 7483  330
             pushFollow(FOLLOW_quadPattern_in_deleteClause2058);
 7484  330
             quadPattern166=quadPattern();
 7485  66
 
 7486  264
             state._fsp--;
 7487  
 
 7488  264
             stream_quadPattern.add(quadPattern166.getTree());
 7489  
 
 7490  66
             // AST REWRITE
 7491  66
             // elements: DELETE, quadPattern
 7492  
             // token labels: 
 7493  
             // rule labels: retval
 7494  66
             // token list labels: 
 7495  66
             // rule list labels: 
 7496  
             // wildcard labels: 
 7497  330
             retval.tree = root_0;
 7498  264
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7499  66
 
 7500  264
             root_0 = (Object)adaptor.nil();
 7501  
             // 264:26: -> ^( DELETE quadPattern )
 7502  
             {
 7503  
                 // com\\googlecode\\sparkleg\\Sparql.g:264:29: ^( DELETE quadPattern )
 7504  
                 {
 7505  264
                 Object root_1 = (Object)adaptor.nil();
 7506  264
                 root_1 = (Object)adaptor.becomeRoot(
 7507  
                 stream_DELETE.nextNode()
 7508  66
                 , root_1);
 7509  66
 
 7510  264
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7511  66
 
 7512  264
                 adaptor.addChild(root_0, root_1);
 7513  
                 }
 7514  
 
 7515  
             }
 7516  66
 
 7517  66
 
 7518  264
             retval.tree = root_0;
 7519  
 
 7520  
             }
 7521  66
 
 7522  264
             retval.stop = input.LT(-1);
 7523  66
 
 7524  
 
 7525  264
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7526  264
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7527  
 
 7528  
         }
 7529  66
         catch (RecognitionException re) {
 7530  0
             reportError(re);
 7531  0
             recover(input,re);
 7532  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7533  66
 
 7534  
         }
 7535  
 
 7536  66
         finally {
 7537  66
                 // do for sure before leaving
 7538  264
         }
 7539  264
         return retval;
 7540  
     }
 7541  
     // $ANTLR end "deleteClause"
 7542  
 
 7543  
 
 7544  96
     public static class insertClause_return extends ParserRuleReturnScope {
 7545  
         Object tree;
 7546  96
         public Object getTree() { return tree; }
 7547  
     };
 7548  
 
 7549  66
 
 7550  66
     // $ANTLR start "insertClause"
 7551  
     // com\\googlecode\\sparkleg\\Sparql.g:267:1: insertClause : INSERT quadPattern -> ^( INSERT quadPattern ) ;
 7552  
     public final SparqlParser.insertClause_return insertClause() throws RecognitionException {
 7553  96
         SparqlParser.insertClause_return retval = new SparqlParser.insertClause_return();
 7554  96
         retval.start = input.LT(1);
 7555  24
 
 7556  
 
 7557  96
         Object root_0 = null;
 7558  
 
 7559  96
         Token INSERT167=null;
 7560  96
         SparqlParser.quadPattern_return quadPattern168 =null;
 7561  
 
 7562  
 
 7563  96
         Object INSERT167_tree=null;
 7564  120
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 7565  120
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7566  
         try {
 7567  
             // com\\googlecode\\sparkleg\\Sparql.g:268:5: ( INSERT quadPattern -> ^( INSERT quadPattern ) )
 7568  24
             // com\\googlecode\\sparkleg\\Sparql.g:268:7: INSERT quadPattern
 7569  
             {
 7570  120
             INSERT167=(Token)match(input,INSERT,FOLLOW_INSERT_in_insertClause2089);  
 7571  120
             stream_INSERT.add(INSERT167);
 7572  
 
 7573  
 
 7574  120
             pushFollow(FOLLOW_quadPattern_in_insertClause2091);
 7575  120
             quadPattern168=quadPattern();
 7576  24
 
 7577  96
             state._fsp--;
 7578  
 
 7579  96
             stream_quadPattern.add(quadPattern168.getTree());
 7580  
 
 7581  24
             // AST REWRITE
 7582  24
             // elements: INSERT, quadPattern
 7583  
             // token labels: 
 7584  
             // rule labels: retval
 7585  24
             // token list labels: 
 7586  24
             // rule list labels: 
 7587  
             // wildcard labels: 
 7588  120
             retval.tree = root_0;
 7589  96
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7590  24
 
 7591  96
             root_0 = (Object)adaptor.nil();
 7592  
             // 268:26: -> ^( INSERT quadPattern )
 7593  
             {
 7594  
                 // com\\googlecode\\sparkleg\\Sparql.g:268:29: ^( INSERT quadPattern )
 7595  
                 {
 7596  96
                 Object root_1 = (Object)adaptor.nil();
 7597  96
                 root_1 = (Object)adaptor.becomeRoot(
 7598  
                 stream_INSERT.nextNode()
 7599  24
                 , root_1);
 7600  24
 
 7601  96
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7602  24
 
 7603  96
                 adaptor.addChild(root_0, root_1);
 7604  
                 }
 7605  
 
 7606  
             }
 7607  24
 
 7608  24
 
 7609  96
             retval.tree = root_0;
 7610  
 
 7611  
             }
 7612  24
 
 7613  96
             retval.stop = input.LT(-1);
 7614  24
 
 7615  
 
 7616  96
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7617  96
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7618  
 
 7619  
         }
 7620  24
         catch (RecognitionException re) {
 7621  0
             reportError(re);
 7622  0
             recover(input,re);
 7623  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7624  24
 
 7625  
         }
 7626  
 
 7627  24
         finally {
 7628  24
                 // do for sure before leaving
 7629  96
         }
 7630  96
         return retval;
 7631  
     }
 7632  
     // $ANTLR end "insertClause"
 7633  
 
 7634  
 
 7635  63
     public static class usingClause_return extends ParserRuleReturnScope {
 7636  
         Object tree;
 7637  63
         public Object getTree() { return tree; }
 7638  
     };
 7639  
 
 7640  24
 
 7641  24
     // $ANTLR start "usingClause"
 7642  
     // com\\googlecode\\sparkleg\\Sparql.g:271:1: usingClause : USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) ;
 7643  
     public final SparqlParser.usingClause_return usingClause() throws RecognitionException {
 7644  63
         SparqlParser.usingClause_return retval = new SparqlParser.usingClause_return();
 7645  63
         retval.start = input.LT(1);
 7646  18
 
 7647  
 
 7648  63
         Object root_0 = null;
 7649  
 
 7650  63
         Token USING169=null;
 7651  63
         Token NAMED170=null;
 7652  63
         SparqlParser.iriRef_return iriRef171 =null;
 7653  
 
 7654  
 
 7655  81
         Object USING169_tree=null;
 7656  81
         Object NAMED170_tree=null;
 7657  63
         RewriteRuleTokenStream stream_USING=new RewriteRuleTokenStream(adaptor,"token USING");
 7658  63
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 7659  81
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7660  
         try {
 7661  18
             // com\\googlecode\\sparkleg\\Sparql.g:272:5: ( USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) )
 7662  18
             // com\\googlecode\\sparkleg\\Sparql.g:272:7: USING ( NAMED )? iriRef
 7663  18
             {
 7664  63
             USING169=(Token)match(input,USING,FOLLOW_USING_in_usingClause2116);  
 7665  63
             stream_USING.add(USING169);
 7666  18
 
 7667  18
 
 7668  18
             // com\\googlecode\\sparkleg\\Sparql.g:272:13: ( NAMED )?
 7669  81
             int alt55=2;
 7670  81
             switch ( input.LA(1) ) {
 7671  
                 case NAMED:
 7672  
                     {
 7673  0
                     alt55=1;
 7674  
                     }
 7675  18
                     break;
 7676  18
             }
 7677  
 
 7678  63
             switch (alt55) {
 7679  
                 case 1 :
 7680  18
                     // com\\googlecode\\sparkleg\\Sparql.g:272:13: NAMED
 7681  18
                     {
 7682  0
                     NAMED170=(Token)match(input,NAMED,FOLLOW_NAMED_in_usingClause2118);  
 7683  0
                     stream_NAMED.add(NAMED170);
 7684  
 
 7685  
 
 7686  
                     }
 7687  
                     break;
 7688  
 
 7689  18
             }
 7690  
 
 7691  
 
 7692  63
             pushFollow(FOLLOW_iriRef_in_usingClause2121);
 7693  63
             iriRef171=iriRef();
 7694  
 
 7695  63
             state._fsp--;
 7696  
 
 7697  63
             stream_iriRef.add(iriRef171.getTree());
 7698  
 
 7699  
             // AST REWRITE
 7700  
             // elements: USING, NAMED, iriRef
 7701  
             // token labels: 
 7702  
             // rule labels: retval
 7703  18
             // token list labels: 
 7704  18
             // rule list labels: 
 7705  
             // wildcard labels: 
 7706  81
             retval.tree = root_0;
 7707  63
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7708  18
 
 7709  63
             root_0 = (Object)adaptor.nil();
 7710  
             // 272:27: -> ^( USING ( NAMED )? iriRef )
 7711  
             {
 7712  
                 // com\\googlecode\\sparkleg\\Sparql.g:272:30: ^( USING ( NAMED )? iriRef )
 7713  
                 {
 7714  63
                 Object root_1 = (Object)adaptor.nil();
 7715  63
                 root_1 = (Object)adaptor.becomeRoot(
 7716  
                 stream_USING.nextNode()
 7717  18
                 , root_1);
 7718  18
 
 7719  
                 // com\\googlecode\\sparkleg\\Sparql.g:272:38: ( NAMED )?
 7720  81
                 if ( stream_NAMED.hasNext() ) {
 7721  0
                     adaptor.addChild(root_1, 
 7722  
                     stream_NAMED.nextNode()
 7723  
                     );
 7724  
 
 7725  18
                 }
 7726  81
                 stream_NAMED.reset();
 7727  
 
 7728  63
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 7729  
 
 7730  63
                 adaptor.addChild(root_0, root_1);
 7731  18
                 }
 7732  
 
 7733  
             }
 7734  
 
 7735  
 
 7736  63
             retval.tree = root_0;
 7737  18
 
 7738  
             }
 7739  18
 
 7740  63
             retval.stop = input.LT(-1);
 7741  18
 
 7742  
 
 7743  63
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7744  63
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7745  
 
 7746  
         }
 7747  18
         catch (RecognitionException re) {
 7748  0
             reportError(re);
 7749  0
             recover(input,re);
 7750  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7751  18
 
 7752  
         }
 7753  
 
 7754  18
         finally {
 7755  18
                 // do for sure before leaving
 7756  63
         }
 7757  63
         return retval;
 7758  
     }
 7759  
     // $ANTLR end "usingClause"
 7760  
 
 7761  
 
 7762  0
     public static class graphOrDefault_return extends ParserRuleReturnScope {
 7763  
         Object tree;
 7764  0
         public Object getTree() { return tree; }
 7765  
     };
 7766  
 
 7767  18
 
 7768  18
     // $ANTLR start "graphOrDefault"
 7769  
     // com\\googlecode\\sparkleg\\Sparql.g:275:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7770  
     public final SparqlParser.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7771  0
         SparqlParser.graphOrDefault_return retval = new SparqlParser.graphOrDefault_return();
 7772  0
         retval.start = input.LT(1);
 7773  
 
 7774  
 
 7775  0
         Object root_0 = null;
 7776  
 
 7777  0
         Token DEFAULT172=null;
 7778  0
         Token GRAPH173=null;
 7779  0
         SparqlParser.iriRef_return iriRef174 =null;
 7780  
 
 7781  
 
 7782  0
         Object DEFAULT172_tree=null;
 7783  0
         Object GRAPH173_tree=null;
 7784  
 
 7785  
         try {
 7786  
             // com\\googlecode\\sparkleg\\Sparql.g:276:5: ( DEFAULT | ( GRAPH )? iriRef )
 7787  0
             int alt57=2;
 7788  0
             switch ( input.LA(1) ) {
 7789  
             case DEFAULT:
 7790  
                 {
 7791  0
                 alt57=1;
 7792  
                 }
 7793  0
                 break;
 7794  
             case GRAPH:
 7795  
             case IRI_REF:
 7796  
             case PNAME_LN:
 7797  
             case PNAME_NS:
 7798  
                 {
 7799  0
                 alt57=2;
 7800  
                 }
 7801  0
                 break;
 7802  
             default:
 7803  0
                 NoViableAltException nvae =
 7804  
                     new NoViableAltException("", 57, 0, input);
 7805  
 
 7806  0
                 throw nvae;
 7807  
 
 7808  
             }
 7809  
 
 7810  0
             switch (alt57) {
 7811  
                 case 1 :
 7812  
                     // com\\googlecode\\sparkleg\\Sparql.g:276:7: DEFAULT
 7813  
                     {
 7814  0
                     root_0 = (Object)adaptor.nil();
 7815  
 
 7816  
 
 7817  0
                     DEFAULT172=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault2152); 
 7818  0
                     DEFAULT172_tree = 
 7819  
                     (Object)adaptor.create(DEFAULT172)
 7820  
                     ;
 7821  0
                     adaptor.addChild(root_0, DEFAULT172_tree);
 7822  
 
 7823  
 
 7824  
                     }
 7825  0
                     break;
 7826  
                 case 2 :
 7827  
                     // com\\googlecode\\sparkleg\\Sparql.g:277:7: ( GRAPH )? iriRef
 7828  
                     {
 7829  0
                     root_0 = (Object)adaptor.nil();
 7830  
 
 7831  
 
 7832  
                     // com\\googlecode\\sparkleg\\Sparql.g:277:7: ( GRAPH )?
 7833  0
                     int alt56=2;
 7834  0
                     switch ( input.LA(1) ) {
 7835  
                         case GRAPH:
 7836  
                             {
 7837  0
                             alt56=1;
 7838  
                             }
 7839  
                             break;
 7840  
                     }
 7841  
 
 7842  0
                     switch (alt56) {
 7843  
                         case 1 :
 7844  
                             // com\\googlecode\\sparkleg\\Sparql.g:277:7: GRAPH
 7845  
                             {
 7846  0
                             GRAPH173=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault2161); 
 7847  0
                             GRAPH173_tree = 
 7848  
                             (Object)adaptor.create(GRAPH173)
 7849  
                             ;
 7850  0
                             adaptor.addChild(root_0, GRAPH173_tree);
 7851  
 
 7852  
 
 7853  
                             }
 7854  
                             break;
 7855  
 
 7856  
                     }
 7857  
 
 7858  
 
 7859  0
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault2164);
 7860  0
                     iriRef174=iriRef();
 7861  
 
 7862  0
                     state._fsp--;
 7863  
 
 7864  0
                     adaptor.addChild(root_0, iriRef174.getTree());
 7865  
 
 7866  
                     }
 7867  
                     break;
 7868  
 
 7869  
             }
 7870  0
             retval.stop = input.LT(-1);
 7871  
 
 7872  
 
 7873  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7874  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7875  
 
 7876  
         }
 7877  0
         catch (RecognitionException re) {
 7878  0
             reportError(re);
 7879  0
             recover(input,re);
 7880  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7881  
 
 7882  
         }
 7883  
 
 7884  0
         finally {
 7885  
                 // do for sure before leaving
 7886  0
         }
 7887  0
         return retval;
 7888  
     }
 7889  
     // $ANTLR end "graphOrDefault"
 7890  
 
 7891  
 
 7892  16
     public static class graphRef_return extends ParserRuleReturnScope {
 7893  
         Object tree;
 7894  16
         public Object getTree() { return tree; }
 7895  
     };
 7896  
 
 7897  
 
 7898  
     // $ANTLR start "graphRef"
 7899  
     // com\\googlecode\\sparkleg\\Sparql.g:280:1: graphRef : GRAPH iriRef ;
 7900  
     public final SparqlParser.graphRef_return graphRef() throws RecognitionException {
 7901  16
         SparqlParser.graphRef_return retval = new SparqlParser.graphRef_return();
 7902  16
         retval.start = input.LT(1);
 7903  4
 
 7904  
 
 7905  16
         Object root_0 = null;
 7906  
 
 7907  16
         Token GRAPH175=null;
 7908  16
         SparqlParser.iriRef_return iriRef176 =null;
 7909  
 
 7910  
 
 7911  16
         Object GRAPH175_tree=null;
 7912  4
 
 7913  4
         try {
 7914  
             // com\\googlecode\\sparkleg\\Sparql.g:281:5: ( GRAPH iriRef )
 7915  
             // com\\googlecode\\sparkleg\\Sparql.g:281:7: GRAPH iriRef
 7916  4
             {
 7917  16
             root_0 = (Object)adaptor.nil();
 7918  4
 
 7919  4
 
 7920  16
             GRAPH175=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef2191); 
 7921  16
             GRAPH175_tree = 
 7922  4
             (Object)adaptor.create(GRAPH175)
 7923  
             ;
 7924  16
             adaptor.addChild(root_0, GRAPH175_tree);
 7925  
 
 7926  
 
 7927  16
             pushFollow(FOLLOW_iriRef_in_graphRef2193);
 7928  20
             iriRef176=iriRef();
 7929  
 
 7930  16
             state._fsp--;
 7931  4
 
 7932  20
             adaptor.addChild(root_0, iriRef176.getTree());
 7933  
 
 7934  
             }
 7935  4
 
 7936  16
             retval.stop = input.LT(-1);
 7937  
 
 7938  4
 
 7939  20
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7940  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7941  4
 
 7942  
         }
 7943  4
         catch (RecognitionException re) {
 7944  0
             reportError(re);
 7945  0
             recover(input,re);
 7946  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7947  4
 
 7948  
         }
 7949  
 
 7950  4
         finally {
 7951  4
                 // do for sure before leaving
 7952  16
         }
 7953  16
         return retval;
 7954  
     }
 7955  
     // $ANTLR end "graphRef"
 7956  
 
 7957  
 
 7958  64
     public static class graphRefAll_return extends ParserRuleReturnScope {
 7959  
         Object tree;
 7960  64
         public Object getTree() { return tree; }
 7961  
     };
 7962  
 
 7963  4
 
 7964  4
     // $ANTLR start "graphRefAll"
 7965  
     // com\\googlecode\\sparkleg\\Sparql.g:284:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7966  
     public final SparqlParser.graphRefAll_return graphRefAll() throws RecognitionException {
 7967  64
         SparqlParser.graphRefAll_return retval = new SparqlParser.graphRefAll_return();
 7968  64
         retval.start = input.LT(1);
 7969  16
 
 7970  
 
 7971  16
         Object root_0 = null;
 7972  
 
 7973  64
         Token DEFAULT178=null;
 7974  64
         Token NAMED179=null;
 7975  64
         Token ALL180=null;
 7976  64
         SparqlParser.graphRef_return graphRef177 =null;
 7977  
 
 7978  16
 
 7979  80
         Object DEFAULT178_tree=null;
 7980  64
         Object NAMED179_tree=null;
 7981  64
         Object ALL180_tree=null;
 7982  16
 
 7983  
         try {
 7984  16
             // com\\googlecode\\sparkleg\\Sparql.g:285:5: ( graphRef | DEFAULT | NAMED | ALL )
 7985  80
             int alt58=4;
 7986  80
             switch ( input.LA(1) ) {
 7987  16
             case GRAPH:
 7988  
                 {
 7989  16
                 alt58=1;
 7990  16
                 }
 7991  32
                 break;
 7992  16
             case DEFAULT:
 7993  
                 {
 7994  16
                 alt58=2;
 7995  
                 }
 7996  32
                 break;
 7997  16
             case NAMED:
 7998  
                 {
 7999  16
                 alt58=3;
 8000  4
                 }
 8001  16
                 break;
 8002  4
             case ALL:
 8003  
                 {
 8004  16
                 alt58=4;
 8005  4
                 }
 8006  16
                 break;
 8007  4
             default:
 8008  0
                 NoViableAltException nvae =
 8009  
                     new NoViableAltException("", 58, 0, input);
 8010  4
 
 8011  0
                 throw nvae;
 8012  4
 
 8013  
             }
 8014  
 
 8015  68
             switch (alt58) {
 8016  
                 case 1 :
 8017  4
                     // com\\googlecode\\sparkleg\\Sparql.g:285:7: graphRef
 8018  
                     {
 8019  16
                     root_0 = (Object)adaptor.nil();
 8020  
 
 8021  
 
 8022  16
                     pushFollow(FOLLOW_graphRef_in_graphRefAll2210);
 8023  16
                     graphRef177=graphRef();
 8024  
 
 8025  16
                     state._fsp--;
 8026  16
 
 8027  16
                     adaptor.addChild(root_0, graphRef177.getTree());
 8028  
 
 8029  
                     }
 8030  20
                     break;
 8031  
                 case 2 :
 8032  
                     // com\\googlecode\\sparkleg\\Sparql.g:285:18: DEFAULT
 8033  4
                     {
 8034  20
                     root_0 = (Object)adaptor.nil();
 8035  
 
 8036  4
 
 8037  16
                     DEFAULT178=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll2214); 
 8038  20
                     DEFAULT178_tree = 
 8039  
                     (Object)adaptor.create(DEFAULT178)
 8040  
                     ;
 8041  20
                     adaptor.addChild(root_0, DEFAULT178_tree);
 8042  
 
 8043  
 
 8044  
                     }
 8045  20
                     break;
 8046  
                 case 3 :
 8047  
                     // com\\googlecode\\sparkleg\\Sparql.g:285:28: NAMED
 8048  4
                     {
 8049  20
                     root_0 = (Object)adaptor.nil();
 8050  
 
 8051  
 
 8052  20
                     NAMED179=(Token)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll2218); 
 8053  16
                     NAMED179_tree = 
 8054  
                     (Object)adaptor.create(NAMED179)
 8055  
                     ;
 8056  20
                     adaptor.addChild(root_0, NAMED179_tree);
 8057  
 
 8058  
 
 8059  
                     }
 8060  20
                     break;
 8061  
                 case 4 :
 8062  
                     // com\\googlecode\\sparkleg\\Sparql.g:285:36: ALL
 8063  4
                     {
 8064  20
                     root_0 = (Object)adaptor.nil();
 8065  
 
 8066  
 
 8067  20
                     ALL180=(Token)match(input,ALL,FOLLOW_ALL_in_graphRefAll2222); 
 8068  16
                     ALL180_tree = 
 8069  
                     (Object)adaptor.create(ALL180)
 8070  
                     ;
 8071  20
                     adaptor.addChild(root_0, ALL180_tree);
 8072  
 
 8073  
 
 8074  
                     }
 8075  4
                     break;
 8076  
 
 8077  
             }
 8078  68
             retval.stop = input.LT(-1);
 8079  4
 
 8080  
 
 8081  64
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8082  68
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8083  
 
 8084  
         }
 8085  0
         catch (RecognitionException re) {
 8086  0
             reportError(re);
 8087  0
             recover(input,re);
 8088  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8089  16
 
 8090  
         }
 8091  
 
 8092  16
         finally {
 8093  16
                 // do for sure before leaving
 8094  64
         }
 8095  64
         return retval;
 8096  
     }
 8097  
     // $ANTLR end "graphRefAll"
 8098  
 
 8099  
 
 8100  488
     public static class quadPattern_return extends ParserRuleReturnScope {
 8101  
         Object tree;
 8102  488
         public Object getTree() { return tree; }
 8103  
     };
 8104  
 
 8105  16
 
 8106  16
     // $ANTLR start "quadPattern"
 8107  
     // com\\googlecode\\sparkleg\\Sparql.g:288:1: quadPattern : '{' quads '}' -> quads ;
 8108  
     public final SparqlParser.quadPattern_return quadPattern() throws RecognitionException {
 8109  488
         SparqlParser.quadPattern_return retval = new SparqlParser.quadPattern_return();
 8110  488
         retval.start = input.LT(1);
 8111  122
 
 8112  
 
 8113  488
         Object root_0 = null;
 8114  
 
 8115  488
         Token char_literal181=null;
 8116  488
         Token char_literal183=null;
 8117  488
         SparqlParser.quads_return quads182 =null;
 8118  
 
 8119  
 
 8120  610
         Object char_literal181_tree=null;
 8121  610
         Object char_literal183_tree=null;
 8122  488
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 8123  488
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 8124  610
         RewriteRuleSubtreeStream stream_quads=new RewriteRuleSubtreeStream(adaptor,"rule quads");
 8125  
         try {
 8126  122
             // com\\googlecode\\sparkleg\\Sparql.g:289:5: ( '{' quads '}' -> quads )
 8127  122
             // com\\googlecode\\sparkleg\\Sparql.g:289:7: '{' quads '}'
 8128  122
             {
 8129  488
             char_literal181=(Token)match(input,216,FOLLOW_216_in_quadPattern2239);  
 8130  488
             stream_216.add(char_literal181);
 8131  122
 
 8132  122
 
 8133  610
             pushFollow(FOLLOW_quads_in_quadPattern2241);
 8134  610
             quads182=quads();
 8135  122
 
 8136  488
             state._fsp--;
 8137  
 
 8138  488
             stream_quads.add(quads182.getTree());
 8139  
 
 8140  610
             char_literal183=(Token)match(input,218,FOLLOW_218_in_quadPattern2243);  
 8141  610
             stream_218.add(char_literal183);
 8142  
 
 8143  
 
 8144  122
             // AST REWRITE
 8145  122
             // elements: quads
 8146  
             // token labels: 
 8147  122
             // rule labels: retval
 8148  
             // token list labels: 
 8149  122
             // rule list labels: 
 8150  
             // wildcard labels: 
 8151  610
             retval.tree = root_0;
 8152  610
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8153  
 
 8154  488
             root_0 = (Object)adaptor.nil();
 8155  
             // 289:21: -> quads
 8156  
             {
 8157  488
                 adaptor.addChild(root_0, stream_quads.nextTree());
 8158  
 
 8159  
             }
 8160  
 
 8161  
 
 8162  610
             retval.tree = root_0;
 8163  122
 
 8164  
             }
 8165  122
 
 8166  488
             retval.stop = input.LT(-1);
 8167  
 
 8168  122
 
 8169  488
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8170  488
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8171  
 
 8172  
         }
 8173  122
         catch (RecognitionException re) {
 8174  0
             reportError(re);
 8175  0
             recover(input,re);
 8176  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8177  122
 
 8178  
         }
 8179  
 
 8180  122
         finally {
 8181  122
                 // do for sure before leaving
 8182  488
         }
 8183  488
         return retval;
 8184  
     }
 8185  
     // $ANTLR end "quadPattern"
 8186  
 
 8187  
 
 8188  488
     public static class quads_return extends ParserRuleReturnScope {
 8189  
         Object tree;
 8190  488
         public Object getTree() { return tree; }
 8191  
     };
 8192  
 
 8193  122
 
 8194  122
     // $ANTLR start "quads"
 8195  
     // com\\googlecode\\sparkleg\\Sparql.g:292:1: quads : ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* ;
 8196  
     public final SparqlParser.quads_return quads() throws RecognitionException {
 8197  488
         SparqlParser.quads_return retval = new SparqlParser.quads_return();
 8198  488
         retval.start = input.LT(1);
 8199  122
 
 8200  
 
 8201  488
         Object root_0 = null;
 8202  
 
 8203  488
         SparqlParser.triplesTemplate_return triplesTemplate184 =null;
 8204  
 
 8205  488
         SparqlParser.quadsDetails_return quadsDetails185 =null;
 8206  
 
 8207  
 
 8208  610
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8209  610
         RewriteRuleSubtreeStream stream_quadsDetails=new RewriteRuleSubtreeStream(adaptor,"rule quadsDetails");
 8210  
         try {
 8211  
             // com\\googlecode\\sparkleg\\Sparql.g:293:5: ( ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* )
 8212  122
             // com\\googlecode\\sparkleg\\Sparql.g:293:7: ( triplesTemplate )? ( quadsDetails )*
 8213  
             {
 8214  122
             // com\\googlecode\\sparkleg\\Sparql.g:293:7: ( triplesTemplate )?
 8215  488
             int alt59=2;
 8216  610
             switch ( input.LA(1) ) {
 8217  
                 case BLANK_NODE_LABEL:
 8218  
                 case DECIMAL:
 8219  122
                 case DECIMAL_NEGATIVE:
 8220  122
                 case DECIMAL_POSITIVE:
 8221  
                 case DOUBLE:
 8222  
                 case DOUBLE_NEGATIVE:
 8223  
                 case DOUBLE_POSITIVE:
 8224  
                 case FALSE:
 8225  
                 case INTEGER:
 8226  122
                 case INTEGER_NEGATIVE:
 8227  122
                 case INTEGER_POSITIVE:
 8228  
                 case IRI_REF:
 8229  
                 case PNAME_LN:
 8230  
                 case PNAME_NS:
 8231  
                 case STRING_LITERAL1:
 8232  
                 case STRING_LITERAL2:
 8233  
                 case STRING_LITERAL_LONG1:
 8234  
                 case STRING_LITERAL_LONG2:
 8235  
                 case TRUE:
 8236  
                 case VAR1:
 8237  
                 case VAR2:
 8238  
                 case 209:
 8239  
                 case 213:
 8240  
                     {
 8241  352
                     alt59=1;
 8242  
                     }
 8243  
                     break;
 8244  
             }
 8245  
 
 8246  488
             switch (alt59) {
 8247  
                 case 1 :
 8248  
                     // com\\googlecode\\sparkleg\\Sparql.g:293:7: triplesTemplate
 8249  
                     {
 8250  352
                     pushFollow(FOLLOW_triplesTemplate_in_quads2268);
 8251  352
                     triplesTemplate184=triplesTemplate();
 8252  88
 
 8253  352
                     state._fsp--;
 8254  
 
 8255  352
                     stream_triplesTemplate.add(triplesTemplate184.getTree());
 8256  
 
 8257  122
                     }
 8258  
                     break;
 8259  
 
 8260  
             }
 8261  88
 
 8262  88
 
 8263  
             // com\\googlecode\\sparkleg\\Sparql.g:293:24: ( quadsDetails )*
 8264  88
             loop60:
 8265  
             do {
 8266  712
                 int alt60=2;
 8267  624
                 switch ( input.LA(1) ) {
 8268  
                 case GRAPH:
 8269  
                     {
 8270  136
                     alt60=1;
 8271  
                     }
 8272  
                     break;
 8273  
 
 8274  
                 }
 8275  
 
 8276  624
                 switch (alt60) {
 8277  156
                     case 1 :
 8278  156
                         // com\\googlecode\\sparkleg\\Sparql.g:293:24: quadsDetails
 8279  
                         {
 8280  136
                         pushFollow(FOLLOW_quadsDetails_in_quads2271);
 8281  170
                         quadsDetails185=quadsDetails();
 8282  
 
 8283  136
                         state._fsp--;
 8284  
 
 8285  136
                         stream_quadsDetails.add(quadsDetails185.getTree());
 8286  
 
 8287  156
                         }
 8288  136
                         break;
 8289  
 
 8290  
                     default :
 8291  522
                         break loop60;
 8292  34
                 }
 8293  136
             } while (true);
 8294  34
 
 8295  
 
 8296  34
             // AST REWRITE
 8297  
             // elements: triplesTemplate, quadsDetails
 8298  
             // token labels: 
 8299  34
             // rule labels: retval
 8300  
             // token list labels: 
 8301  
             // rule list labels: 
 8302  122
             // wildcard labels: 
 8303  488
             retval.tree = root_0;
 8304  522
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8305  
 
 8306  488
             root_0 = (Object)adaptor.nil();
 8307  
             // 293:38: -> ( triplesTemplate )? ( quadsDetails )*
 8308  
             {
 8309  
                 // com\\googlecode\\sparkleg\\Sparql.g:293:42: ( triplesTemplate )?
 8310  488
                 if ( stream_triplesTemplate.hasNext() ) {
 8311  352
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8312  
 
 8313  
                 }
 8314  610
                 stream_triplesTemplate.reset();
 8315  122
 
 8316  
                 // com\\googlecode\\sparkleg\\Sparql.g:293:59: ( quadsDetails )*
 8317  746
                 while ( stream_quadsDetails.hasNext() ) {
 8318  136
                     adaptor.addChild(root_0, stream_quadsDetails.nextTree());
 8319  
 
 8320  
                 }
 8321  610
                 stream_quadsDetails.reset();
 8322  88
 
 8323  
             }
 8324  
 
 8325  122
 
 8326  488
             retval.tree = root_0;
 8327  
 
 8328  156
             }
 8329  34
 
 8330  488
             retval.stop = input.LT(-1);
 8331  
 
 8332  122
 
 8333  488
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8334  488
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8335  
 
 8336  
         }
 8337  122
         catch (RecognitionException re) {
 8338  0
             reportError(re);
 8339  0
             recover(input,re);
 8340  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8341  122
 
 8342  
         }
 8343  
 
 8344  122
         finally {
 8345  122
                 // do for sure before leaving
 8346  488
         }
 8347  488
         return retval;
 8348  
     }
 8349  
     // $ANTLR end "quads"
 8350  
 
 8351  
 
 8352  136
     public static class quadsDetails_return extends ParserRuleReturnScope {
 8353  
         Object tree;
 8354  136
         public Object getTree() { return tree; }
 8355  
     };
 8356  
 
 8357  122
 
 8358  122
     // $ANTLR start "quadsDetails"
 8359  
     // com\\googlecode\\sparkleg\\Sparql.g:296:1: quadsDetails : quadsNotTriples ( '.' )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? ;
 8360  
     public final SparqlParser.quadsDetails_return quadsDetails() throws RecognitionException {
 8361  136
         SparqlParser.quadsDetails_return retval = new SparqlParser.quadsDetails_return();
 8362  136
         retval.start = input.LT(1);
 8363  34
 
 8364  
 
 8365  136
         Object root_0 = null;
 8366  
 
 8367  136
         Token char_literal187=null;
 8368  136
         SparqlParser.quadsNotTriples_return quadsNotTriples186 =null;
 8369  
 
 8370  136
         SparqlParser.triplesTemplate_return triplesTemplate188 =null;
 8371  
 
 8372  34
 
 8373  170
         Object char_literal187_tree=null;
 8374  136
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8375  136
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8376  170
         RewriteRuleSubtreeStream stream_quadsNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule quadsNotTriples");
 8377  
         try {
 8378  34
             // com\\googlecode\\sparkleg\\Sparql.g:297:5: ( quadsNotTriples ( '.' )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? )
 8379  34
             // com\\googlecode\\sparkleg\\Sparql.g:297:7: quadsNotTriples ( '.' )? ( triplesTemplate )?
 8380  
             {
 8381  170
             pushFollow(FOLLOW_quadsNotTriples_in_quadsDetails2303);
 8382  136
             quadsNotTriples186=quadsNotTriples();
 8383  
 
 8384  170
             state._fsp--;
 8385  34
 
 8386  170
             stream_quadsNotTriples.add(quadsNotTriples186.getTree());
 8387  34
 
 8388  
             // com\\googlecode\\sparkleg\\Sparql.g:297:23: ( '.' )?
 8389  136
             int alt61=2;
 8390  136
             switch ( input.LA(1) ) {
 8391  
                 case DOT:
 8392  34
                     {
 8393  34
                     alt61=1;
 8394  
                     }
 8395  34
                     break;
 8396  
             }
 8397  34
 
 8398  136
             switch (alt61) {
 8399  
                 case 1 :
 8400  34
                     // com\\googlecode\\sparkleg\\Sparql.g:297:23: '.'
 8401  34
                     {
 8402  0
                     char_literal187=(Token)match(input,DOT,FOLLOW_DOT_in_quadsDetails2305);  
 8403  0
                     stream_DOT.add(char_literal187);
 8404  
 
 8405  
 
 8406  
                     }
 8407  
                     break;
 8408  
 
 8409  34
             }
 8410  
 
 8411  
 
 8412  
             // com\\googlecode\\sparkleg\\Sparql.g:297:28: ( triplesTemplate )?
 8413  136
             int alt62=2;
 8414  136
             switch ( input.LA(1) ) {
 8415  
                 case BLANK_NODE_LABEL:
 8416  
                 case DECIMAL:
 8417  
                 case DECIMAL_NEGATIVE:
 8418  
                 case DECIMAL_POSITIVE:
 8419  
                 case DOUBLE:
 8420  
                 case DOUBLE_NEGATIVE:
 8421  
                 case DOUBLE_POSITIVE:
 8422  
                 case FALSE:
 8423  
                 case INTEGER:
 8424  34
                 case INTEGER_NEGATIVE:
 8425  34
                 case INTEGER_POSITIVE:
 8426  
                 case IRI_REF:
 8427  
                 case PNAME_LN:
 8428  
                 case PNAME_NS:
 8429  
                 case STRING_LITERAL1:
 8430  
                 case STRING_LITERAL2:
 8431  
                 case STRING_LITERAL_LONG1:
 8432  
                 case STRING_LITERAL_LONG2:
 8433  
                 case TRUE:
 8434  
                 case VAR1:
 8435  
                 case VAR2:
 8436  
                 case 209:
 8437  
                 case 213:
 8438  
                     {
 8439  0
                     alt62=1;
 8440  
                     }
 8441  
                     break;
 8442  
             }
 8443  
 
 8444  136
             switch (alt62) {
 8445  
                 case 1 :
 8446  
                     // com\\googlecode\\sparkleg\\Sparql.g:297:28: triplesTemplate
 8447  
                     {
 8448  0
                     pushFollow(FOLLOW_triplesTemplate_in_quadsDetails2308);
 8449  0
                     triplesTemplate188=triplesTemplate();
 8450  
 
 8451  0
                     state._fsp--;
 8452  
 
 8453  0
                     stream_triplesTemplate.add(triplesTemplate188.getTree());
 8454  
 
 8455  34
                     }
 8456  
                     break;
 8457  
 
 8458  
             }
 8459  
 
 8460  
 
 8461  
             // AST REWRITE
 8462  
             // elements: quadsNotTriples, triplesTemplate
 8463  
             // token labels: 
 8464  
             // rule labels: retval
 8465  
             // token list labels: 
 8466  
             // rule list labels: 
 8467  
             // wildcard labels: 
 8468  136
             retval.tree = root_0;
 8469  136
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8470  
 
 8471  136
             root_0 = (Object)adaptor.nil();
 8472  
             // 297:45: -> quadsNotTriples ( triplesTemplate )?
 8473  
             {
 8474  136
                 adaptor.addChild(root_0, stream_quadsNotTriples.nextTree());
 8475  
 
 8476  
                 // com\\googlecode\\sparkleg\\Sparql.g:297:64: ( triplesTemplate )?
 8477  136
                 if ( stream_triplesTemplate.hasNext() ) {
 8478  0
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8479  34
 
 8480  34
                 }
 8481  136
                 stream_triplesTemplate.reset();
 8482  34
 
 8483  
             }
 8484  
 
 8485  34
 
 8486  136
             retval.tree = root_0;
 8487  
 
 8488  34
             }
 8489  
 
 8490  136
             retval.stop = input.LT(-1);
 8491  
 
 8492  34
 
 8493  136
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8494  136
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8495  
 
 8496  
         }
 8497  34
         catch (RecognitionException re) {
 8498  0
             reportError(re);
 8499  0
             recover(input,re);
 8500  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8501  34
 
 8502  
         }
 8503  
 
 8504  34
         finally {
 8505  34
                 // do for sure before leaving
 8506  136
         }
 8507  136
         return retval;
 8508  
     }
 8509  
     // $ANTLR end "quadsDetails"
 8510  
 
 8511  
 
 8512  136
     public static class quadsNotTriples_return extends ParserRuleReturnScope {
 8513  
         Object tree;
 8514  136
         public Object getTree() { return tree; }
 8515  
     };
 8516  
 
 8517  34
 
 8518  34
     // $ANTLR start "quadsNotTriples"
 8519  
     // com\\googlecode\\sparkleg\\Sparql.g:300:1: quadsNotTriples : GRAPH varOrIRIref '{' ( triplesTemplate )? '}' -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 8520  
     public final SparqlParser.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 8521  136
         SparqlParser.quadsNotTriples_return retval = new SparqlParser.quadsNotTriples_return();
 8522  136
         retval.start = input.LT(1);
 8523  34
 
 8524  
 
 8525  136
         Object root_0 = null;
 8526  
 
 8527  136
         Token GRAPH189=null;
 8528  136
         Token char_literal191=null;
 8529  136
         Token char_literal193=null;
 8530  136
         SparqlParser.varOrIRIref_return varOrIRIref190 =null;
 8531  
 
 8532  170
         SparqlParser.triplesTemplate_return triplesTemplate192 =null;
 8533  34
 
 8534  
 
 8535  136
         Object GRAPH189_tree=null;
 8536  170
         Object char_literal191_tree=null;
 8537  136
         Object char_literal193_tree=null;
 8538  170
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 8539  170
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 8540  170
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 8541  170
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 8542  136
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8543  34
         try {
 8544  
             // com\\googlecode\\sparkleg\\Sparql.g:301:5: ( GRAPH varOrIRIref '{' ( triplesTemplate )? '}' -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 8545  
             // com\\googlecode\\sparkleg\\Sparql.g:301:7: GRAPH varOrIRIref '{' ( triplesTemplate )? '}'
 8546  34
             {
 8547  170
             GRAPH189=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples2338);  
 8548  170
             stream_GRAPH.add(GRAPH189);
 8549  34
 
 8550  34
 
 8551  170
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples2340);
 8552  170
             varOrIRIref190=varOrIRIref();
 8553  34
 
 8554  136
             state._fsp--;
 8555  
 
 8556  136
             stream_varOrIRIref.add(varOrIRIref190.getTree());
 8557  
 
 8558  170
             char_literal191=(Token)match(input,216,FOLLOW_216_in_quadsNotTriples2342);  
 8559  170
             stream_216.add(char_literal191);
 8560  
 
 8561  
 
 8562  34
             // com\\googlecode\\sparkleg\\Sparql.g:301:29: ( triplesTemplate )?
 8563  170
             int alt63=2;
 8564  136
             switch ( input.LA(1) ) {
 8565  34
                 case BLANK_NODE_LABEL:
 8566  
                 case DECIMAL:
 8567  34
                 case DECIMAL_NEGATIVE:
 8568  
                 case DECIMAL_POSITIVE:
 8569  34
                 case DOUBLE:
 8570  34
                 case DOUBLE_NEGATIVE:
 8571  
                 case DOUBLE_POSITIVE:
 8572  
                 case FALSE:
 8573  
                 case INTEGER:
 8574  34
                 case INTEGER_NEGATIVE:
 8575  34
                 case INTEGER_POSITIVE:
 8576  
                 case IRI_REF:
 8577  
                 case PNAME_LN:
 8578  
                 case PNAME_NS:
 8579  
                 case STRING_LITERAL1:
 8580  
                 case STRING_LITERAL2:
 8581  
                 case STRING_LITERAL_LONG1:
 8582  
                 case STRING_LITERAL_LONG2:
 8583  
                 case TRUE:
 8584  
                 case VAR1:
 8585  
                 case VAR2:
 8586  
                 case 209:
 8587  
                 case 213:
 8588  
                     {
 8589  136
                     alt63=1;
 8590  
                     }
 8591  
                     break;
 8592  
             }
 8593  
 
 8594  136
             switch (alt63) {
 8595  
                 case 1 :
 8596  
                     // com\\googlecode\\sparkleg\\Sparql.g:301:29: triplesTemplate
 8597  
                     {
 8598  136
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples2344);
 8599  136
                     triplesTemplate192=triplesTemplate();
 8600  34
 
 8601  136
                     state._fsp--;
 8602  
 
 8603  136
                     stream_triplesTemplate.add(triplesTemplate192.getTree());
 8604  
 
 8605  34
                     }
 8606  
                     break;
 8607  
 
 8608  
             }
 8609  34
 
 8610  34
 
 8611  136
             char_literal193=(Token)match(input,218,FOLLOW_218_in_quadsNotTriples2347);  
 8612  170
             stream_218.add(char_literal193);
 8613  
 
 8614  34
 
 8615  
             // AST REWRITE
 8616  
             // elements: GRAPH, varOrIRIref, triplesTemplate
 8617  
             // token labels: 
 8618  
             // rule labels: retval
 8619  
             // token list labels: 
 8620  
             // rule list labels: 
 8621  
             // wildcard labels: 
 8622  170
             retval.tree = root_0;
 8623  170
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8624  
 
 8625  136
             root_0 = (Object)adaptor.nil();
 8626  
             // 301:50: -> ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8627  
             {
 8628  
                 // com\\googlecode\\sparkleg\\Sparql.g:301:53: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8629  
                 {
 8630  136
                 Object root_1 = (Object)adaptor.nil();
 8631  136
                 root_1 = (Object)adaptor.becomeRoot(
 8632  
                 stream_GRAPH.nextNode()
 8633  34
                 , root_1);
 8634  34
 
 8635  136
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 8636  34
 
 8637  
                 // com\\googlecode\\sparkleg\\Sparql.g:301:73: ( triplesTemplate )?
 8638  136
                 if ( stream_triplesTemplate.hasNext() ) {
 8639  136
                     adaptor.addChild(root_1, stream_triplesTemplate.nextTree());
 8640  
 
 8641  34
                 }
 8642  170
                 stream_triplesTemplate.reset();
 8643  
 
 8644  136
                 adaptor.addChild(root_0, root_1);
 8645  
                 }
 8646  34
 
 8647  
             }
 8648  
 
 8649  34
 
 8650  170
             retval.tree = root_0;
 8651  
 
 8652  
             }
 8653  34
 
 8654  136
             retval.stop = input.LT(-1);
 8655  34
 
 8656  
 
 8657  136
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8658  136
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8659  
 
 8660  
         }
 8661  34
         catch (RecognitionException re) {
 8662  0
             reportError(re);
 8663  0
             recover(input,re);
 8664  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8665  34
 
 8666  
         }
 8667  
 
 8668  34
         finally {
 8669  34
                 // do for sure before leaving
 8670  136
         }
 8671  136
         return retval;
 8672  
     }
 8673  
     // $ANTLR end "quadsNotTriples"
 8674  
 
 8675  
 
 8676  538
     public static class triplesTemplate_return extends ParserRuleReturnScope {
 8677  
         Object tree;
 8678  538
         public Object getTree() { return tree; }
 8679  
     };
 8680  
 
 8681  34
 
 8682  34
     // $ANTLR start "triplesTemplate"
 8683  
     // com\\googlecode\\sparkleg\\Sparql.g:304:1: triplesTemplate : triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 8684  
     public final SparqlParser.triplesTemplate_return triplesTemplate() throws RecognitionException {
 8685  538
         SparqlParser.triplesTemplate_return retval = new SparqlParser.triplesTemplate_return();
 8686  538
         retval.start = input.LT(1);
 8687  136
 
 8688  
 
 8689  538
         Object root_0 = null;
 8690  
 
 8691  538
         Token char_literal195=null;
 8692  538
         Token char_literal197=null;
 8693  538
         SparqlParser.triplesSameSubject_return triplesSameSubject194 =null;
 8694  
 
 8695  538
         SparqlParser.triplesSameSubject_return triplesSameSubject196 =null;
 8696  136
 
 8697  136
 
 8698  538
         Object char_literal195_tree=null;
 8699  538
         Object char_literal197_tree=null;
 8700  674
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8701  538
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 8702  136
         try {
 8703  136
             // com\\googlecode\\sparkleg\\Sparql.g:305:5: ( triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 8704  136
             // com\\googlecode\\sparkleg\\Sparql.g:305:7: triplesSameSubject ( '.' triplesSameSubject )* ( '.' )?
 8705  
             {
 8706  674
             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2379);
 8707  538
             triplesSameSubject194=triplesSameSubject();
 8708  
 
 8709  674
             state._fsp--;
 8710  136
 
 8711  674
             stream_triplesSameSubject.add(triplesSameSubject194.getTree());
 8712  136
 
 8713  
             // com\\googlecode\\sparkleg\\Sparql.g:305:26: ( '.' triplesSameSubject )*
 8714  
             loop64:
 8715  
             do {
 8716  562
                 int alt64=2;
 8717  698
                 switch ( input.LA(1) ) {
 8718  136
                 case DOT:
 8719  
                     {
 8720  556
                     switch ( input.LA(2) ) {
 8721  
                     case BLANK_NODE_LABEL:
 8722  136
                     case DECIMAL:
 8723  
                     case DECIMAL_NEGATIVE:
 8724  
                     case DECIMAL_POSITIVE:
 8725  
                     case DOUBLE:
 8726  
                     case DOUBLE_NEGATIVE:
 8727  142
                     case DOUBLE_POSITIVE:
 8728  142
                     case FALSE:
 8729  
                     case INTEGER:
 8730  
                     case INTEGER_NEGATIVE:
 8731  84
                     case INTEGER_POSITIVE:
 8732  
                     case IRI_REF:
 8733  
                     case PNAME_LN:
 8734  
                     case PNAME_NS:
 8735  
                     case STRING_LITERAL1:
 8736  
                     case STRING_LITERAL2:
 8737  
                     case STRING_LITERAL_LONG1:
 8738  
                     case STRING_LITERAL_LONG2:
 8739  
                     case TRUE:
 8740  
                     case VAR1:
 8741  
                     case VAR2:
 8742  
                     case 209:
 8743  
                     case 213:
 8744  
                         {
 8745  24
                         alt64=1;
 8746  
                         }
 8747  
                         break;
 8748  
 
 8749  
                     }
 8750  
 
 8751  
                     }
 8752  
                     break;
 8753  
 
 8754  
                 }
 8755  
 
 8756  568
                 switch (alt64) {
 8757  
                     case 1 :
 8758  
                         // com\\googlecode\\sparkleg\\Sparql.g:305:27: '.' triplesSameSubject
 8759  
                         {
 8760  24
                         char_literal195=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2382);  
 8761  24
                         stream_DOT.add(char_literal195);
 8762  
 
 8763  
 
 8764  24
                         pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2384);
 8765  24
                         triplesSameSubject196=triplesSameSubject();
 8766  
 
 8767  166
                         state._fsp--;
 8768  
 
 8769  24
                         stream_triplesSameSubject.add(triplesSameSubject196.getTree());
 8770  
 
 8771  6
                         }
 8772  30
                         break;
 8773  
 
 8774  
                     default :
 8775  544
                         break loop64;
 8776  6
                 }
 8777  24
             } while (true);
 8778  6
 
 8779  
 
 8780  6
             // com\\googlecode\\sparkleg\\Sparql.g:305:52: ( '.' )?
 8781  538
             int alt65=2;
 8782  538
             switch ( input.LA(1) ) {
 8783  6
                 case DOT:
 8784  
                     {
 8785  396
                     alt65=1;
 8786  136
                     }
 8787  
                     break;
 8788  6
             }
 8789  
 
 8790  538
             switch (alt65) {
 8791  
                 case 1 :
 8792  136
                     // com\\googlecode\\sparkleg\\Sparql.g:305:52: '.'
 8793  136
                     {
 8794  396
                     char_literal197=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2388);  
 8795  396
                     stream_DOT.add(char_literal197);
 8796  78
 
 8797  
 
 8798  
                     }
 8799  
                     break;
 8800  
 
 8801  136
             }
 8802  
 
 8803  
 
 8804  
             // AST REWRITE
 8805  78
             // elements: triplesSameSubject
 8806  78
             // token labels: 
 8807  
             // rule labels: retval
 8808  
             // token list labels: 
 8809  
             // rule list labels: 
 8810  
             // wildcard labels: 
 8811  538
             retval.tree = root_0;
 8812  538
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8813  
 
 8814  538
             root_0 = (Object)adaptor.nil();
 8815  
             // 305:57: -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8816  
             {
 8817  
                 // com\\googlecode\\sparkleg\\Sparql.g:305:60: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8818  
                 {
 8819  538
                 Object root_1 = (Object)adaptor.nil();
 8820  538
                 root_1 = (Object)adaptor.becomeRoot(
 8821  
                 (Object)adaptor.create(TRIPLES_TEMPLATE, "TRIPLES_TEMPLATE")
 8822  136
                 , root_1);
 8823  136
 
 8824  
                 // com\\googlecode\\sparkleg\\Sparql.g:305:79: ( triplesSameSubject )*
 8825  1236
                 while ( stream_triplesSameSubject.hasNext() ) {
 8826  562
                     adaptor.addChild(root_1, stream_triplesSameSubject.nextTree());
 8827  
 
 8828  
                 }
 8829  538
                 stream_triplesSameSubject.reset();
 8830  136
 
 8831  674
                 adaptor.addChild(root_0, root_1);
 8832  
                 }
 8833  
 
 8834  
             }
 8835  
 
 8836  278
 
 8837  680
             retval.tree = root_0;
 8838  
 
 8839  
             }
 8840  136
 
 8841  538
             retval.stop = input.LT(-1);
 8842  136
 
 8843  
 
 8844  538
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8845  538
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8846  
 
 8847  
         }
 8848  136
         catch (RecognitionException re) {
 8849  0
             reportError(re);
 8850  0
             recover(input,re);
 8851  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8852  136
 
 8853  
         }
 8854  
 
 8855  136
         finally {
 8856  136
                 // do for sure before leaving
 8857  538
         }
 8858  538
         return retval;
 8859  
     }
 8860  
     // $ANTLR end "triplesTemplate"
 8861  
 
 8862  
 
 8863  10558
     public static class groupGraphPattern_return extends ParserRuleReturnScope {
 8864  
         Object tree;
 8865  10558
         public Object getTree() { return tree; }
 8866  
     };
 8867  
 
 8868  136
 
 8869  136
     // $ANTLR start "groupGraphPattern"
 8870  
     // com\\googlecode\\sparkleg\\Sparql.g:308:1: groupGraphPattern : ( '{' subSelect '}' -> ^( GROUP_GRAPH_PATTERN subSelect ) | '{' groupGraphPatternSub '}' -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | '{' '}' -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 8871  
     public final SparqlParser.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 8872  10558
         SparqlParser.groupGraphPattern_return retval = new SparqlParser.groupGraphPattern_return();
 8873  10558
         retval.start = input.LT(1);
 8874  2692
 
 8875  
 
 8876  2692
         Object root_0 = null;
 8877  
 
 8878  10558
         Token char_literal198=null;
 8879  10558
         Token char_literal200=null;
 8880  10558
         Token char_literal201=null;
 8881  10558
         Token char_literal203=null;
 8882  10558
         Token char_literal204=null;
 8883  13250
         Token char_literal205=null;
 8884  13250
         SparqlParser.subSelect_return subSelect199 =null;
 8885  
 
 8886  10558
         SparqlParser.groupGraphPatternSub_return groupGraphPatternSub202 =null;
 8887  2692
 
 8888  
 
 8889  13250
         Object char_literal198_tree=null;
 8890  13250
         Object char_literal200_tree=null;
 8891  13250
         Object char_literal201_tree=null;
 8892  13250
         Object char_literal203_tree=null;
 8893  13250
         Object char_literal204_tree=null;
 8894  13250
         Object char_literal205_tree=null;
 8895  13250
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 8896  10558
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 8897  13250
         RewriteRuleSubtreeStream stream_groupGraphPatternSub=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSub");
 8898  10558
         RewriteRuleSubtreeStream stream_subSelect=new RewriteRuleSubtreeStream(adaptor,"rule subSelect");
 8899  
         try {
 8900  2692
             // com\\googlecode\\sparkleg\\Sparql.g:309:5: ( '{' subSelect '}' -> ^( GROUP_GRAPH_PATTERN subSelect ) | '{' groupGraphPatternSub '}' -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | '{' '}' -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 8901  13250
             int alt66=3;
 8902  13250
             switch ( input.LA(1) ) {
 8903  2692
             case 216:
 8904  2692
                 {
 8905  13238
                 switch ( input.LA(2) ) {
 8906  2692
                 case 218:
 8907  2692
                     {
 8908  2868
                     alt66=3;
 8909  2692
                     }
 8910  176
                     break;
 8911  
                 case SELECT:
 8912  2692
                     {
 8913  2876
                     alt66=1;
 8914  
                     }
 8915  184
                     break;
 8916  2680
                 case BIND:
 8917  
                 case BLANK_NODE_LABEL:
 8918  
                 case DECIMAL:
 8919  44
                 case DECIMAL_NEGATIVE:
 8920  
                 case DECIMAL_POSITIVE:
 8921  44
                 case DOUBLE:
 8922  
                 case DOUBLE_NEGATIVE:
 8923  
                 case DOUBLE_POSITIVE:
 8924  46
                 case FALSE:
 8925  
                 case FILTER:
 8926  46
                 case GRAPH:
 8927  
                 case INTEGER:
 8928  
                 case INTEGER_NEGATIVE:
 8929  
                 case INTEGER_POSITIVE:
 8930  
                 case IRI_REF:
 8931  
                 case MINUS_KEYWORD:
 8932  
                 case OPTIONAL:
 8933  
                 case PNAME_LN:
 8934  
                 case PNAME_NS:
 8935  
                 case SERVICE:
 8936  
                 case STRING_LITERAL1:
 8937  
                 case STRING_LITERAL2:
 8938  
                 case STRING_LITERAL_LONG1:
 8939  
                 case STRING_LITERAL_LONG2:
 8940  
                 case TRUE:
 8941  
                 case VAR1:
 8942  
                 case VAR2:
 8943  
                 case 209:
 8944  
                 case 213:
 8945  
                 case 216:
 8946  
                     {
 8947  10176
                     alt66=2;
 8948  
                     }
 8949  10176
                     break;
 8950  
                 default:
 8951  10
                     NoViableAltException nvae =
 8952  
                         new NoViableAltException("", 66, 1, input);
 8953  
 
 8954  10
                     throw nvae;
 8955  
 
 8956  
                 }
 8957  
 
 8958  2580
                 }
 8959  10536
                 break;
 8960  2580
             default:
 8961  12
                 NoViableAltException nvae =
 8962  10
                     new NoViableAltException("", 66, 0, input);
 8963  
 
 8964  12
                 throw nvae;
 8965  10
 
 8966  
             }
 8967  
 
 8968  10536
             switch (alt66) {
 8969  
                 case 1 :
 8970  2670
                     // com\\googlecode\\sparkleg\\Sparql.g:309:7: '{' subSelect '}'
 8971  
                     {
 8972  196
                     char_literal198=(Token)match(input,216,FOLLOW_216_in_groupGraphPattern2420);  
 8973  184
                     stream_216.add(char_literal198);
 8974  
 
 8975  12
 
 8976  184
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern2422);
 8977  184
                     subSelect199=subSelect();
 8978  
 
 8979  2854
                     state._fsp--;
 8980  
 
 8981  184
                     stream_subSelect.add(subSelect199.getTree());
 8982  
 
 8983  230
                     char_literal200=(Token)match(input,218,FOLLOW_218_in_groupGraphPattern2424);  
 8984  230
                     stream_218.add(char_literal200);
 8985  
 
 8986  
 
 8987  46
                     // AST REWRITE
 8988  46
                     // elements: subSelect
 8989  
                     // token labels: 
 8990  46
                     // rule labels: retval
 8991  
                     // token list labels: 
 8992  46
                     // rule list labels: 
 8993  
                     // wildcard labels: 
 8994  230
                     retval.tree = root_0;
 8995  230
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8996  
 
 8997  184
                     root_0 = (Object)adaptor.nil();
 8998  
                     // 309:25: -> ^( GROUP_GRAPH_PATTERN subSelect )
 8999  
                     {
 9000  
                         // com\\googlecode\\sparkleg\\Sparql.g:309:28: ^( GROUP_GRAPH_PATTERN subSelect )
 9001  
                         {
 9002  184
                         Object root_1 = (Object)adaptor.nil();
 9003  184
                         root_1 = (Object)adaptor.becomeRoot(
 9004  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9005  46
                         , root_1);
 9006  46
 
 9007  184
                         adaptor.addChild(root_1, stream_subSelect.nextTree());
 9008  46
 
 9009  184
                         adaptor.addChild(root_0, root_1);
 9010  
                         }
 9011  
 
 9012  
                     }
 9013  46
 
 9014  46
 
 9015  184
                     retval.tree = root_0;
 9016  
 
 9017  
                     }
 9018  230
                     break;
 9019  
                 case 2 :
 9020  46
                     // com\\googlecode\\sparkleg\\Sparql.g:310:7: '{' groupGraphPatternSub '}'
 9021  
                     {
 9022  10176
                     char_literal201=(Token)match(input,216,FOLLOW_216_in_groupGraphPattern2440);  
 9023  10176
                     stream_216.add(char_literal201);
 9024  
 
 9025  
 
 9026  10222
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern2442);
 9027  10176
                     groupGraphPatternSub202=groupGraphPatternSub();
 9028  
 
 9029  10222
                     state._fsp--;
 9030  
 
 9031  10176
                     stream_groupGraphPatternSub.add(groupGraphPatternSub202.getTree());
 9032  
 
 9033  12756
                     char_literal203=(Token)match(input,218,FOLLOW_218_in_groupGraphPattern2444);  
 9034  12738
                     stream_218.add(char_literal203);
 9035  
 
 9036  
 
 9037  2580
                     // AST REWRITE
 9038  2580
                     // elements: groupGraphPatternSub
 9039  
                     // token labels: 
 9040  2580
                     // rule labels: retval
 9041  
                     // token list labels: 
 9042  2580
                     // rule list labels: 
 9043  
                     // wildcard labels: 
 9044  12738
                     retval.tree = root_0;
 9045  12720
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9046  
 
 9047  10158
                     root_0 = (Object)adaptor.nil();
 9048  
                     // 310:36: -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 9049  
                     {
 9050  
                         // com\\googlecode\\sparkleg\\Sparql.g:310:39: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 9051  
                         {
 9052  10158
                         Object root_1 = (Object)adaptor.nil();
 9053  10158
                         root_1 = (Object)adaptor.becomeRoot(
 9054  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9055  2562
                         , root_1);
 9056  2562
 
 9057  10158
                         adaptor.addChild(root_1, stream_groupGraphPatternSub.nextTree());
 9058  2562
 
 9059  10158
                         adaptor.addChild(root_0, root_1);
 9060  
                         }
 9061  
 
 9062  
                     }
 9063  2562
 
 9064  2562
 
 9065  10158
                     retval.tree = root_0;
 9066  
 
 9067  
                     }
 9068  12720
                     break;
 9069  
                 case 3 :
 9070  2562
                     // com\\googlecode\\sparkleg\\Sparql.g:311:7: '{' '}'
 9071  
                     {
 9072  176
                     char_literal204=(Token)match(input,216,FOLLOW_216_in_groupGraphPattern2460);  
 9073  176
                     stream_216.add(char_literal204);
 9074  
 
 9075  
 
 9076  2738
                     char_literal205=(Token)match(input,218,FOLLOW_218_in_groupGraphPattern2462);  
 9077  176
                     stream_218.add(char_literal205);
 9078  
 
 9079  2562
 
 9080  
                     // AST REWRITE
 9081  
                     // elements: 
 9082  
                     // token labels: 
 9083  44
                     // rule labels: retval
 9084  44
                     // token list labels: 
 9085  
                     // rule list labels: 
 9086  
                     // wildcard labels: 
 9087  220
                     retval.tree = root_0;
 9088  220
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9089  
 
 9090  176
                     root_0 = (Object)adaptor.nil();
 9091  
                     // 311:15: -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9092  
                     {
 9093  
                         // com\\googlecode\\sparkleg\\Sparql.g:311:18: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9094  
                         {
 9095  176
                         Object root_1 = (Object)adaptor.nil();
 9096  176
                         root_1 = (Object)adaptor.becomeRoot(
 9097  
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9098  44
                         , root_1);
 9099  44
 
 9100  176
                         adaptor.addChild(root_1, 
 9101  44
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9102  
                         );
 9103  
 
 9104  176
                         adaptor.addChild(root_0, root_1);
 9105  
                         }
 9106  44
 
 9107  44
                     }
 9108  
 
 9109  
 
 9110  176
                     retval.tree = root_0;
 9111  44
 
 9112  
                     }
 9113  
                     break;
 9114  
 
 9115  44
             }
 9116  10518
             retval.stop = input.LT(-1);
 9117  
 
 9118  
 
 9119  10518
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9120  10518
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9121  44
 
 9122  
         }
 9123  40
         catch (RecognitionException re) {
 9124  40
             reportError(re);
 9125  40
             recover(input,re);
 9126  40
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9127  2652
 
 9128  
         }
 9129  
 
 9130  2652
         finally {
 9131  2652
                 // do for sure before leaving
 9132  10558
         }
 9133  10558
         return retval;
 9134  40
     }
 9135  40
     // $ANTLR end "groupGraphPattern"
 9136  40
 
 9137  40
 
 9138  10176
     public static class groupGraphPatternSub_return extends ParserRuleReturnScope {
 9139  
         Object tree;
 9140  10176
         public Object getTree() { return tree; }
 9141  
     };
 9142  
 
 9143  2692
 
 9144  2692
     // $ANTLR start "groupGraphPatternSub"
 9145  
     // com\\googlecode\\sparkleg\\Sparql.g:314:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ );
 9146  
     public final SparqlParser.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 9147  10176
         SparqlParser.groupGraphPatternSub_return retval = new SparqlParser.groupGraphPatternSub_return();
 9148  10176
         retval.start = input.LT(1);
 9149  2580
 
 9150  
 
 9151  10176
         Object root_0 = null;
 9152  
 
 9153  10176
         SparqlParser.triplesBlock_return triplesBlock206 =null;
 9154  
 
 9155  10176
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail207 =null;
 9156  
 
 9157  10176
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail208 =null;
 9158  2580
 
 9159  2580
 
 9160  10176
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9161  10176
         RewriteRuleSubtreeStream stream_groupGraphPatternSubDetail=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSubDetail");
 9162  2580
         try {
 9163  
             // com\\googlecode\\sparkleg\\Sparql.g:315:5: ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ )
 9164  12756
             int alt69=2;
 9165  10176
             switch ( input.LA(1) ) {
 9166  2580
             case BLANK_NODE_LABEL:
 9167  
             case DECIMAL:
 9168  2580
             case DECIMAL_NEGATIVE:
 9169  
             case DECIMAL_POSITIVE:
 9170  
             case DOUBLE:
 9171  2580
             case DOUBLE_NEGATIVE:
 9172  2580
             case DOUBLE_POSITIVE:
 9173  
             case FALSE:
 9174  
             case INTEGER:
 9175  2580
             case INTEGER_NEGATIVE:
 9176  2580
             case INTEGER_POSITIVE:
 9177  
             case IRI_REF:
 9178  
             case PNAME_LN:
 9179  
             case PNAME_NS:
 9180  
             case STRING_LITERAL1:
 9181  
             case STRING_LITERAL2:
 9182  
             case STRING_LITERAL_LONG1:
 9183  
             case STRING_LITERAL_LONG2:
 9184  
             case TRUE:
 9185  
             case VAR1:
 9186  
             case VAR2:
 9187  
             case 209:
 9188  
             case 213:
 9189  
                 {
 9190  9056
                 alt69=1;
 9191  
                 }
 9192  9056
                 break;
 9193  
             case BIND:
 9194  
             case FILTER:
 9195  
             case GRAPH:
 9196  
             case MINUS_KEYWORD:
 9197  
             case OPTIONAL:
 9198  
             case SERVICE:
 9199  
             case 216:
 9200  
                 {
 9201  3414
                 alt69=2;
 9202  
                 }
 9203  3414
                 break;
 9204  
             default:
 9205  0
                 NoViableAltException nvae =
 9206  
                     new NoViableAltException("", 69, 0, input);
 9207  
 
 9208  0
                 throw nvae;
 9209  
 
 9210  
             }
 9211  
 
 9212  10462
             switch (alt69) {
 9213  
                 case 1 :
 9214  286
                     // com\\googlecode\\sparkleg\\Sparql.g:315:7: triplesBlock ( groupGraphPatternSubDetail )*
 9215  
                     {
 9216  9056
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub2491);
 9217  9056
                     triplesBlock206=triplesBlock();
 9218  
 
 9219  9056
                     state._fsp--;
 9220  
 
 9221  9056
                     stream_triplesBlock.add(triplesBlock206.getTree());
 9222  
 
 9223  2580
                     // com\\googlecode\\sparkleg\\Sparql.g:315:20: ( groupGraphPatternSubDetail )*
 9224  
                     loop67:
 9225  
                     do {
 9226  12552
                         int alt67=2;
 9227  14846
                         switch ( input.LA(1) ) {
 9228  2294
                         case BIND:
 9229  
                         case FILTER:
 9230  2294
                         case GRAPH:
 9231  
                         case MINUS_KEYWORD:
 9232  2294
                         case OPTIONAL:
 9233  
                         case SERVICE:
 9234  
                         case 216:
 9235  
                             {
 9236  3496
                             alt67=1;
 9237  3174
                             }
 9238  3174
                             break;
 9239  
 
 9240  
                         }
 9241  
 
 9242  12552
                         switch (alt67) {
 9243  
                             case 1 :
 9244  
                                 // com\\googlecode\\sparkleg\\Sparql.g:315:20: groupGraphPatternSubDetail
 9245  
                                 {
 9246  3496
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2493);
 9247  4376
                                 groupGraphPatternSubDetail207=groupGraphPatternSubDetail();
 9248  
 
 9249  3496
                                 state._fsp--;
 9250  
 
 9251  3496
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail207.getTree());
 9252  
 
 9253  3174
                                 }
 9254  3496
                                 break;
 9255  
 
 9256  
                             default :
 9257  9936
                                 break loop67;
 9258  880
                         }
 9259  3496
                     } while (true);
 9260  880
 
 9261  
 
 9262  880
                     // AST REWRITE
 9263  
                     // elements: triplesBlock, groupGraphPatternSubDetail
 9264  
                     // token labels: 
 9265  880
                     // rule labels: retval
 9266  
                     // token list labels: 
 9267  
                     // rule list labels: 
 9268  2294
                     // wildcard labels: 
 9269  9056
                     retval.tree = root_0;
 9270  9936
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9271  
 
 9272  9056
                     root_0 = (Object)adaptor.nil();
 9273  
                     // 315:48: -> triplesBlock ( groupGraphPatternSubDetail )*
 9274  
                     {
 9275  9056
                         adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9276  
 
 9277  
                         // com\\googlecode\\sparkleg\\Sparql.g:315:64: ( groupGraphPatternSubDetail )*
 9278  12552
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9279  3496
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9280  2294
 
 9281  2294
                         }
 9282  9056
                         stream_groupGraphPatternSubDetail.reset();
 9283  2294
 
 9284  
                     }
 9285  
 
 9286  2294
 
 9287  9056
                     retval.tree = root_0;
 9288  
 
 9289  3174
                     }
 9290  9936
                     break;
 9291  
                 case 2 :
 9292  
                     // com\\googlecode\\sparkleg\\Sparql.g:316:7: ( groupGraphPatternSubDetail )+
 9293  2294
                     {
 9294  
                     // com\\googlecode\\sparkleg\\Sparql.g:316:7: ( groupGraphPatternSubDetail )+
 9295  1120
                     int cnt68=0;
 9296  
                     loop68:
 9297  
                     do {
 9298  4800
                         int alt68=2;
 9299  2506
                         switch ( input.LA(1) ) {
 9300  
                         case BIND:
 9301  2294
                         case FILTER:
 9302  
                         case GRAPH:
 9303  
                         case MINUS_KEYWORD:
 9304  
                         case OPTIONAL:
 9305  
                         case SERVICE:
 9306  286
                         case 216:
 9307  
                             {
 9308  1386
                             alt68=1;
 9309  646
                             }
 9310  646
                             break;
 9311  
 
 9312  
                         }
 9313  
 
 9314  2506
                         switch (alt68) {
 9315  
                             case 1 :
 9316  
                                 // com\\googlecode\\sparkleg\\Sparql.g:316:7: groupGraphPatternSubDetail
 9317  
                                 {
 9318  1386
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2509);
 9319  1746
                                 groupGraphPatternSubDetail208=groupGraphPatternSubDetail();
 9320  
 
 9321  1386
                                 state._fsp--;
 9322  
 
 9323  1386
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail208.getTree());
 9324  
 
 9325  646
                                 }
 9326  1386
                                 break;
 9327  
 
 9328  
                             default :
 9329  1480
                                 if ( cnt68 >= 1 ) break loop68;
 9330  360
                                 EarlyExitException eee =
 9331  
                                     new EarlyExitException(68, input);
 9332  360
                                 throw eee;
 9333  
                         }
 9334  1746
                         cnt68++;
 9335  1386
                     } while (true);
 9336  
 
 9337  360
 
 9338  
                     // AST REWRITE
 9339  
                     // elements: groupGraphPatternSubDetail
 9340  286
                     // token labels: 
 9341  
                     // rule labels: retval
 9342  
                     // token list labels: 
 9343  
                     // rule list labels: 
 9344  
                     // wildcard labels: 
 9345  1480
                     retval.tree = root_0;
 9346  1480
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9347  
 
 9348  1120
                     root_0 = (Object)adaptor.nil();
 9349  
                     // 316:35: -> ( groupGraphPatternSubDetail )+
 9350  
                     {
 9351  1120
                         if ( !(stream_groupGraphPatternSubDetail.hasNext()) ) {
 9352  0
                             throw new RewriteEarlyExitException();
 9353  
                         }
 9354  2506
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9355  1386
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9356  286
 
 9357  286
                         }
 9358  1120
                         stream_groupGraphPatternSubDetail.reset();
 9359  286
 
 9360  
                     }
 9361  
 
 9362  286
 
 9363  1120
                     retval.tree = root_0;
 9364  
 
 9365  646
                     }
 9366  360
                     break;
 9367  
 
 9368  
             }
 9369  10462
             retval.stop = input.LT(-1);
 9370  
 
 9371  
 
 9372  10176
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9373  10176
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9374  286
 
 9375  
         }
 9376  0
         catch (RecognitionException re) {
 9377  0
             reportError(re);
 9378  0
             recover(input,re);
 9379  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9380  2580
 
 9381  
         }
 9382  
 
 9383  2580
         finally {
 9384  2580
                 // do for sure before leaving
 9385  10176
         }
 9386  10176
         return retval;
 9387  
     }
 9388  
     // $ANTLR end "groupGraphPatternSub"
 9389  
 
 9390  
 
 9391  4882
     public static class groupGraphPatternSubDetail_return extends ParserRuleReturnScope {
 9392  
         Object tree;
 9393  4882
         public Object getTree() { return tree; }
 9394  
     };
 9395  
 
 9396  2580
 
 9397  2580
     // $ANTLR start "groupGraphPatternSubDetail"
 9398  
     // com\\googlecode\\sparkleg\\Sparql.g:319:1: groupGraphPatternSubDetail : graphPatternNotTriples ( '.' )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? ;
 9399  
     public final SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 9400  4882
         SparqlParser.groupGraphPatternSubDetail_return retval = new SparqlParser.groupGraphPatternSubDetail_return();
 9401  4882
         retval.start = input.LT(1);
 9402  1240
 
 9403  
 
 9404  1240
         Object root_0 = null;
 9405  
 
 9406  4882
         Token char_literal210=null;
 9407  4882
         SparqlParser.graphPatternNotTriples_return graphPatternNotTriples209 =null;
 9408  
 
 9409  4882
         SparqlParser.triplesBlock_return triplesBlock211 =null;
 9410  
 
 9411  1240
 
 9412  6122
         Object char_literal210_tree=null;
 9413  4882
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9414  4882
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9415  6122
         RewriteRuleSubtreeStream stream_graphPatternNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule graphPatternNotTriples");
 9416  
         try {
 9417  1240
             // com\\googlecode\\sparkleg\\Sparql.g:320:5: ( graphPatternNotTriples ( '.' )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? )
 9418  1240
             // com\\googlecode\\sparkleg\\Sparql.g:320:7: graphPatternNotTriples ( '.' )? ( triplesBlock )?
 9419  
             {
 9420  6122
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2532);
 9421  4882
             graphPatternNotTriples209=graphPatternNotTriples();
 9422  
 
 9423  6122
             state._fsp--;
 9424  1240
 
 9425  6122
             stream_graphPatternNotTriples.add(graphPatternNotTriples209.getTree());
 9426  1240
 
 9427  
             // com\\googlecode\\sparkleg\\Sparql.g:320:30: ( '.' )?
 9428  4882
             int alt70=2;
 9429  4882
             switch ( input.LA(1) ) {
 9430  
                 case DOT:
 9431  1240
                     {
 9432  1730
                     alt70=1;
 9433  
                     }
 9434  1240
                     break;
 9435  
             }
 9436  1240
 
 9437  4882
             switch (alt70) {
 9438  
                 case 1 :
 9439  1240
                     // com\\googlecode\\sparkleg\\Sparql.g:320:30: '.'
 9440  1240
                     {
 9441  490
                     char_literal210=(Token)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail2534);  
 9442  490
                     stream_DOT.add(char_literal210);
 9443  196
 
 9444  
 
 9445  
                     }
 9446  
                     break;
 9447  
 
 9448  1240
             }
 9449  
 
 9450  
 
 9451  
             // com\\googlecode\\sparkleg\\Sparql.g:320:35: ( triplesBlock )?
 9452  5078
             int alt71=2;
 9453  5078
             switch ( input.LA(1) ) {
 9454  
                 case BLANK_NODE_LABEL:
 9455  
                 case DECIMAL:
 9456  
                 case DECIMAL_NEGATIVE:
 9457  
                 case DECIMAL_POSITIVE:
 9458  
                 case DOUBLE:
 9459  
                 case DOUBLE_NEGATIVE:
 9460  
                 case DOUBLE_POSITIVE:
 9461  
                 case FALSE:
 9462  
                 case INTEGER:
 9463  1240
                 case INTEGER_NEGATIVE:
 9464  1240
                 case INTEGER_POSITIVE:
 9465  
                 case IRI_REF:
 9466  
                 case PNAME_LN:
 9467  
                 case PNAME_NS:
 9468  
                 case STRING_LITERAL1:
 9469  
                 case STRING_LITERAL2:
 9470  
                 case STRING_LITERAL_LONG1:
 9471  
                 case STRING_LITERAL_LONG2:
 9472  
                 case TRUE:
 9473  
                 case VAR1:
 9474  
                 case VAR2:
 9475  
                 case 209:
 9476  
                 case 213:
 9477  
                     {
 9478  318
                     alt71=1;
 9479  
                     }
 9480  
                     break;
 9481  
             }
 9482  
 
 9483  4882
             switch (alt71) {
 9484  
                 case 1 :
 9485  
                     // com\\googlecode\\sparkleg\\Sparql.g:320:35: triplesBlock
 9486  
                     {
 9487  318
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2537);
 9488  318
                     triplesBlock211=triplesBlock();
 9489  84
 
 9490  318
                     state._fsp--;
 9491  
 
 9492  318
                     stream_triplesBlock.add(triplesBlock211.getTree());
 9493  
 
 9494  1240
                     }
 9495  
                     break;
 9496  
 
 9497  
             }
 9498  84
 
 9499  84
 
 9500  
             // AST REWRITE
 9501  84
             // elements: graphPatternNotTriples, triplesBlock
 9502  
             // token labels: 
 9503  84
             // rule labels: retval
 9504  
             // token list labels: 
 9505  
             // rule list labels: 
 9506  
             // wildcard labels: 
 9507  4882
             retval.tree = root_0;
 9508  4882
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9509  
 
 9510  4882
             root_0 = (Object)adaptor.nil();
 9511  
             // 320:49: -> graphPatternNotTriples ( triplesBlock )?
 9512  
             {
 9513  4882
                 adaptor.addChild(root_0, stream_graphPatternNotTriples.nextTree());
 9514  
 
 9515  
                 // com\\googlecode\\sparkleg\\Sparql.g:320:75: ( triplesBlock )?
 9516  4882
                 if ( stream_triplesBlock.hasNext() ) {
 9517  318
                     adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9518  1240
 
 9519  1240
                 }
 9520  4882
                 stream_triplesBlock.reset();
 9521  1240
 
 9522  
             }
 9523  
 
 9524  1240
 
 9525  4882
             retval.tree = root_0;
 9526  
 
 9527  1240
             }
 9528  84
 
 9529  4882
             retval.stop = input.LT(-1);
 9530  
 
 9531  1240
 
 9532  4882
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9533  4882
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9534  
 
 9535  
         }
 9536  1240
         catch (RecognitionException re) {
 9537  0
             reportError(re);
 9538  0
             recover(input,re);
 9539  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9540  1240
 
 9541  
         }
 9542  
 
 9543  1240
         finally {
 9544  1240
                 // do for sure before leaving
 9545  4882
         }
 9546  4882
         return retval;
 9547  
     }
 9548  
     // $ANTLR end "groupGraphPatternSubDetail"
 9549  
 
 9550  
 
 9551  9374
     public static class triplesBlock_return extends ParserRuleReturnScope {
 9552  
         Object tree;
 9553  9374
         public Object getTree() { return tree; }
 9554  
     };
 9555  
 
 9556  1240
 
 9557  1240
     // $ANTLR start "triplesBlock"
 9558  
     // com\\googlecode\\sparkleg\\Sparql.g:323:1: triplesBlock : triplesSameSubjectPath ( '.' triplesSameSubjectPath )* ( '.' )? -> ( triplesSameSubjectPath )+ ;
 9559  
     public final SparqlParser.triplesBlock_return triplesBlock() throws RecognitionException {
 9560  9374
         SparqlParser.triplesBlock_return retval = new SparqlParser.triplesBlock_return();
 9561  9374
         retval.start = input.LT(1);
 9562  2378
 
 9563  
 
 9564  2378
         Object root_0 = null;
 9565  
 
 9566  9374
         Token char_literal213=null;
 9567  9374
         Token char_literal215=null;
 9568  9374
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath212 =null;
 9569  
 
 9570  9374
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath214 =null;
 9571  2378
 
 9572  2378
 
 9573  9374
         Object char_literal213_tree=null;
 9574  9374
         Object char_literal215_tree=null;
 9575  11752
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9576  9374
         RewriteRuleSubtreeStream stream_triplesSameSubjectPath=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubjectPath");
 9577  2378
         try {
 9578  2378
             // com\\googlecode\\sparkleg\\Sparql.g:324:5: ( triplesSameSubjectPath ( '.' triplesSameSubjectPath )* ( '.' )? -> ( triplesSameSubjectPath )+ )
 9579  2378
             // com\\googlecode\\sparkleg\\Sparql.g:324:7: triplesSameSubjectPath ( '.' triplesSameSubjectPath )* ( '.' )?
 9580  
             {
 9581  11752
             pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2562);
 9582  9374
             triplesSameSubjectPath212=triplesSameSubjectPath();
 9583  
 
 9584  11752
             state._fsp--;
 9585  2378
 
 9586  11752
             stream_triplesSameSubjectPath.add(triplesSameSubjectPath212.getTree());
 9587  2378
 
 9588  
             // com\\googlecode\\sparkleg\\Sparql.g:324:30: ( '.' triplesSameSubjectPath )*
 9589  
             loop72:
 9590  
             do {
 9591  11634
                 int alt72=2;
 9592  14012
                 switch ( input.LA(1) ) {
 9593  2378
                 case DOT:
 9594  
                     {
 9595  6908
                     switch ( input.LA(2) ) {
 9596  
                     case BLANK_NODE_LABEL:
 9597  2378
                     case DECIMAL:
 9598  
                     case DECIMAL_NEGATIVE:
 9599  
                     case DECIMAL_POSITIVE:
 9600  
                     case DOUBLE:
 9601  
                     case DOUBLE_NEGATIVE:
 9602  2946
                     case DOUBLE_POSITIVE:
 9603  2946
                     case FALSE:
 9604  
                     case INTEGER:
 9605  
                     case INTEGER_NEGATIVE:
 9606  1482
                     case INTEGER_POSITIVE:
 9607  
                     case IRI_REF:
 9608  
                     case PNAME_LN:
 9609  
                     case PNAME_NS:
 9610  
                     case STRING_LITERAL1:
 9611  
                     case STRING_LITERAL2:
 9612  
                     case STRING_LITERAL_LONG1:
 9613  
                     case STRING_LITERAL_LONG2:
 9614  
                     case TRUE:
 9615  
                     case VAR1:
 9616  
                     case VAR2:
 9617  
                     case 209:
 9618  
                     case 213:
 9619  
                         {
 9620  2260
                         alt72=1;
 9621  
                         }
 9622  
                         break;
 9623  
 
 9624  
                     }
 9625  
 
 9626  
                     }
 9627  
                     break;
 9628  
 
 9629  
                 }
 9630  
 
 9631  12202
                 switch (alt72) {
 9632  
                     case 1 :
 9633  
                         // com\\googlecode\\sparkleg\\Sparql.g:324:31: '.' triplesSameSubjectPath
 9634  
                         {
 9635  2260
                         char_literal213=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2565);  
 9636  2260
                         stream_DOT.add(char_literal213);
 9637  
 
 9638  
 
 9639  2260
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2567);
 9640  2260
                         triplesSameSubjectPath214=triplesSameSubjectPath();
 9641  
 
 9642  5206
                         state._fsp--;
 9643  
 
 9644  2260
                         stream_triplesSameSubjectPath.add(triplesSameSubjectPath214.getTree());
 9645  
 
 9646  568
                         }
 9647  2828
                         break;
 9648  
 
 9649  
                     default :
 9650  9942
                         break loop72;
 9651  568
                 }
 9652  2260
             } while (true);
 9653  568
 
 9654  
 
 9655  568
             // com\\googlecode\\sparkleg\\Sparql.g:324:60: ( '.' )?
 9656  9374
             int alt73=2;
 9657  9374
             switch ( input.LA(1) ) {
 9658  568
                 case DOT:
 9659  
                     {
 9660  2270
                     alt73=1;
 9661  2378
                     }
 9662  
                     break;
 9663  568
             }
 9664  
 
 9665  9374
             switch (alt73) {
 9666  
                 case 1 :
 9667  2378
                     // com\\googlecode\\sparkleg\\Sparql.g:324:60: '.'
 9668  2378
                     {
 9669  2270
                     char_literal215=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2571);  
 9670  2270
                     stream_DOT.add(char_literal215);
 9671  914
 
 9672  
 
 9673  
                     }
 9674  
                     break;
 9675  
 
 9676  2378
             }
 9677  
 
 9678  
 
 9679  
             // AST REWRITE
 9680  914
             // elements: triplesSameSubjectPath
 9681  914
             // token labels: 
 9682  
             // rule labels: retval
 9683  
             // token list labels: 
 9684  
             // rule list labels: 
 9685  
             // wildcard labels: 
 9686  9374
             retval.tree = root_0;
 9687  9374
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9688  
 
 9689  9374
             root_0 = (Object)adaptor.nil();
 9690  
             // 324:65: -> ( triplesSameSubjectPath )+
 9691  
             {
 9692  9374
                 if ( !(stream_triplesSameSubjectPath.hasNext()) ) {
 9693  0
                     throw new RewriteEarlyExitException();
 9694  
                 }
 9695  21008
                 while ( stream_triplesSameSubjectPath.hasNext() ) {
 9696  11634
                     adaptor.addChild(root_0, stream_triplesSameSubjectPath.nextTree());
 9697  2378
 
 9698  2378
                 }
 9699  9374
                 stream_triplesSameSubjectPath.reset();
 9700  2378
 
 9701  
             }
 9702  
 
 9703  2378
 
 9704  9374
             retval.tree = root_0;
 9705  
 
 9706  5324
             }
 9707  2946
 
 9708  9374
             retval.stop = input.LT(-1);
 9709  
 
 9710  2378
 
 9711  9374
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9712  9374
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9713  
 
 9714  
         }
 9715  2378
         catch (RecognitionException re) {
 9716  0
             reportError(re);
 9717  0
             recover(input,re);
 9718  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9719  2378
 
 9720  
         }
 9721  
 
 9722  2378
         finally {
 9723  2378
                 // do for sure before leaving
 9724  9374
         }
 9725  9374
         return retval;
 9726  
     }
 9727  
     // $ANTLR end "triplesBlock"
 9728  
 
 9729  
 
 9730  4882
     public static class graphPatternNotTriples_return extends ParserRuleReturnScope {
 9731  
         Object tree;
 9732  4882
         public Object getTree() { return tree; }
 9733  
     };
 9734  
 
 9735  2378
 
 9736  2378
     // $ANTLR start "graphPatternNotTriples"
 9737  
     // com\\googlecode\\sparkleg\\Sparql.g:327:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 9738  
     public final SparqlParser.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 9739  4882
         SparqlParser.graphPatternNotTriples_return retval = new SparqlParser.graphPatternNotTriples_return();
 9740  4882
         retval.start = input.LT(1);
 9741  1240
 
 9742  
 
 9743  4882
         Object root_0 = null;
 9744  
 
 9745  4882
         SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern216 =null;
 9746  
 
 9747  4882
         SparqlParser.optionalGraphPattern_return optionalGraphPattern217 =null;
 9748  
 
 9749  4882
         SparqlParser.minusGraphPattern_return minusGraphPattern218 =null;
 9750  1240
 
 9751  6122
         SparqlParser.graphGraphPattern_return graphGraphPattern219 =null;
 9752  
 
 9753  4882
         SparqlParser.serviceGraphPattern_return serviceGraphPattern220 =null;
 9754  1240
 
 9755  4882
         SparqlParser.filter_return filter221 =null;
 9756  1240
 
 9757  4882
         SparqlParser.bind_return bind222 =null;
 9758  1240
 
 9759  
 
 9760  1240
 
 9761  
         try {
 9762  1240
             // com\\googlecode\\sparkleg\\Sparql.g:328:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 9763  4882
             int alt74=7;
 9764  6122
             switch ( input.LA(1) ) {
 9765  
             case 216:
 9766  1240
                 {
 9767  706
                 alt74=1;
 9768  1240
                 }
 9769  706
                 break;
 9770  
             case OPTIONAL:
 9771  
                 {
 9772  758
                 alt74=2;
 9773  
                 }
 9774  1998
                 break;
 9775  1240
             case MINUS_KEYWORD:
 9776  
                 {
 9777  168
                 alt74=3;
 9778  178
                 }
 9779  168
                 break;
 9780  178
             case GRAPH:
 9781  
                 {
 9782  604
                 alt74=4;
 9783  194
                 }
 9784  604
                 break;
 9785  194
             case SERVICE:
 9786  
                 {
 9787  104
                 alt74=5;
 9788  42
                 }
 9789  104
                 break;
 9790  42
             case FILTER:
 9791  
                 {
 9792  2342
                 alt74=6;
 9793  154
                 }
 9794  2342
                 break;
 9795  154
             case BIND:
 9796  
                 {
 9797  200
                 alt74=7;
 9798  26
                 }
 9799  200
                 break;
 9800  26
             default:
 9801  0
                 NoViableAltException nvae =
 9802  
                     new NoViableAltException("", 74, 0, input);
 9803  596
 
 9804  0
                 throw nvae;
 9805  596
 
 9806  
             }
 9807  
 
 9808  4932
             switch (alt74) {
 9809  
                 case 1 :
 9810  50
                     // com\\googlecode\\sparkleg\\Sparql.g:328:7: groupOrUnionGraphPattern
 9811  
                     {
 9812  706
                     root_0 = (Object)adaptor.nil();
 9813  
 
 9814  
 
 9815  706
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2594);
 9816  706
                     groupOrUnionGraphPattern216=groupOrUnionGraphPattern();
 9817  
 
 9818  706
                     state._fsp--;
 9819  1240
 
 9820  706
                     adaptor.addChild(root_0, groupOrUnionGraphPattern216.getTree());
 9821  
 
 9822  
                     }
 9823  884
                     break;
 9824  
                 case 2 :
 9825  
                     // com\\googlecode\\sparkleg\\Sparql.g:328:34: optionalGraphPattern
 9826  178
                     {
 9827  936
                     root_0 = (Object)adaptor.nil();
 9828  
 
 9829  178
 
 9830  758
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2598);
 9831  936
                     optionalGraphPattern217=optionalGraphPattern();
 9832  
 
 9833  758
                     state._fsp--;
 9834  178
 
 9835  758
                     adaptor.addChild(root_0, optionalGraphPattern217.getTree());
 9836  
 
 9837  
                     }
 9838  952
                     break;
 9839  
                 case 3 :
 9840  
                     // com\\googlecode\\sparkleg\\Sparql.g:328:57: minusGraphPattern
 9841  194
                     {
 9842  362
                     root_0 = (Object)adaptor.nil();
 9843  
 
 9844  194
 
 9845  168
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples2602);
 9846  362
                     minusGraphPattern218=minusGraphPattern();
 9847  
 
 9848  168
                     state._fsp--;
 9849  194
 
 9850  168
                     adaptor.addChild(root_0, minusGraphPattern218.getTree());
 9851  
 
 9852  
                     }
 9853  210
                     break;
 9854  
                 case 4 :
 9855  
                     // com\\googlecode\\sparkleg\\Sparql.g:328:77: graphGraphPattern
 9856  42
                     {
 9857  646
                     root_0 = (Object)adaptor.nil();
 9858  
 
 9859  42
 
 9860  604
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples2606);
 9861  646
                     graphGraphPattern219=graphGraphPattern();
 9862  
 
 9863  604
                     state._fsp--;
 9864  42
 
 9865  604
                     adaptor.addChild(root_0, graphGraphPattern219.getTree());
 9866  
 
 9867  
                     }
 9868  758
                     break;
 9869  
                 case 5 :
 9870  
                     // com\\googlecode\\sparkleg\\Sparql.g:328:97: serviceGraphPattern
 9871  154
                     {
 9872  258
                     root_0 = (Object)adaptor.nil();
 9873  
 
 9874  154
 
 9875  104
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2610);
 9876  258
                     serviceGraphPattern220=serviceGraphPattern();
 9877  
 
 9878  104
                     state._fsp--;
 9879  154
 
 9880  104
                     adaptor.addChild(root_0, serviceGraphPattern220.getTree());
 9881  
 
 9882  
                     }
 9883  130
                     break;
 9884  
                 case 6 :
 9885  
                     // com\\googlecode\\sparkleg\\Sparql.g:328:119: filter
 9886  26
                     {
 9887  2368
                     root_0 = (Object)adaptor.nil();
 9888  
 
 9889  26
 
 9890  2342
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples2614);
 9891  2368
                     filter221=filter();
 9892  
 
 9893  2342
                     state._fsp--;
 9894  26
 
 9895  2342
                     adaptor.addChild(root_0, filter221.getTree());
 9896  
 
 9897  
                     }
 9898  2938
                     break;
 9899  
                 case 7 :
 9900  
                     // com\\googlecode\\sparkleg\\Sparql.g:328:128: bind
 9901  596
                     {
 9902  796
                     root_0 = (Object)adaptor.nil();
 9903  
 
 9904  596
 
 9905  200
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples2618);
 9906  796
                     bind222=bind();
 9907  
 
 9908  200
                     state._fsp--;
 9909  596
 
 9910  200
                     adaptor.addChild(root_0, bind222.getTree());
 9911  
 
 9912  
                     }
 9913  50
                     break;
 9914  
 
 9915  
             }
 9916  4932
             retval.stop = input.LT(-1);
 9917  50
 
 9918  
 
 9919  4932
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9920  4882
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9921  50
 
 9922  
         }
 9923  0
         catch (RecognitionException re) {
 9924  0
             reportError(re);
 9925  0
             recover(input,re);
 9926  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9927  1240
 
 9928  
         }
 9929  
 
 9930  1240
         finally {
 9931  1240
                 // do for sure before leaving
 9932  4882
         }
 9933  4882
         return retval;
 9934  
     }
 9935  
     // $ANTLR end "graphPatternNotTriples"
 9936  
 
 9937  
 
 9938  758
     public static class optionalGraphPattern_return extends ParserRuleReturnScope {
 9939  
         Object tree;
 9940  758
         public Object getTree() { return tree; }
 9941  
     };
 9942  
 
 9943  1240
 
 9944  1240
     // $ANTLR start "optionalGraphPattern"
 9945  
     // com\\googlecode\\sparkleg\\Sparql.g:331:1: optionalGraphPattern : OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) ;
 9946  
     public final SparqlParser.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 9947  758
         SparqlParser.optionalGraphPattern_return retval = new SparqlParser.optionalGraphPattern_return();
 9948  758
         retval.start = input.LT(1);
 9949  194
 
 9950  
 
 9951  758
         Object root_0 = null;
 9952  
 
 9953  758
         Token OPTIONAL223=null;
 9954  758
         SparqlParser.groupGraphPattern_return groupGraphPattern224 =null;
 9955  
 
 9956  
 
 9957  758
         Object OPTIONAL223_tree=null;
 9958  952
         RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
 9959  952
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9960  
         try {
 9961  
             // com\\googlecode\\sparkleg\\Sparql.g:332:5: ( OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) )
 9962  194
             // com\\googlecode\\sparkleg\\Sparql.g:332:7: OPTIONAL groupGraphPattern
 9963  
             {
 9964  952
             OPTIONAL223=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern2635);  
 9965  952
             stream_OPTIONAL.add(OPTIONAL223);
 9966  
 
 9967  
 
 9968  952
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern2637);
 9969  952
             groupGraphPattern224=groupGraphPattern();
 9970  194
 
 9971  758
             state._fsp--;
 9972  
 
 9973  758
             stream_groupGraphPattern.add(groupGraphPattern224.getTree());
 9974  
 
 9975  194
             // AST REWRITE
 9976  194
             // elements: groupGraphPattern, OPTIONAL
 9977  
             // token labels: 
 9978  
             // rule labels: retval
 9979  194
             // token list labels: 
 9980  194
             // rule list labels: 
 9981  
             // wildcard labels: 
 9982  952
             retval.tree = root_0;
 9983  758
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9984  194
 
 9985  758
             root_0 = (Object)adaptor.nil();
 9986  
             // 332:34: -> ^( OPTIONAL groupGraphPattern )
 9987  
             {
 9988  
                 // com\\googlecode\\sparkleg\\Sparql.g:332:37: ^( OPTIONAL groupGraphPattern )
 9989  
                 {
 9990  758
                 Object root_1 = (Object)adaptor.nil();
 9991  758
                 root_1 = (Object)adaptor.becomeRoot(
 9992  
                 stream_OPTIONAL.nextNode()
 9993  194
                 , root_1);
 9994  194
 
 9995  758
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9996  194
 
 9997  758
                 adaptor.addChild(root_0, root_1);
 9998  
                 }
 9999  
 
 10000  
             }
 10001  194
 
 10002  194
 
 10003  758
             retval.tree = root_0;
 10004  
 
 10005  
             }
 10006  194
 
 10007  758
             retval.stop = input.LT(-1);
 10008  194
 
 10009  
 
 10010  758
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10011  758
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10012  
 
 10013  
         }
 10014  194
         catch (RecognitionException re) {
 10015  0
             reportError(re);
 10016  0
             recover(input,re);
 10017  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10018  194
 
 10019  
         }
 10020  
 
 10021  194
         finally {
 10022  194
                 // do for sure before leaving
 10023  758
         }
 10024  758
         return retval;
 10025  
     }
 10026  
     // $ANTLR end "optionalGraphPattern"
 10027  
 
 10028  
 
 10029  604
     public static class graphGraphPattern_return extends ParserRuleReturnScope {
 10030  
         Object tree;
 10031  604
         public Object getTree() { return tree; }
 10032  
     };
 10033  
 
 10034  194
 
 10035  194
     // $ANTLR start "graphGraphPattern"
 10036  
     // com\\googlecode\\sparkleg\\Sparql.g:335:1: graphGraphPattern : GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) ;
 10037  
     public final SparqlParser.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 10038  604
         SparqlParser.graphGraphPattern_return retval = new SparqlParser.graphGraphPattern_return();
 10039  604
         retval.start = input.LT(1);
 10040  154
 
 10041  
 
 10042  154
         Object root_0 = null;
 10043  
 
 10044  604
         Token GRAPH225=null;
 10045  604
         SparqlParser.varOrIRIref_return varOrIRIref226 =null;
 10046  
 
 10047  604
         SparqlParser.groupGraphPattern_return groupGraphPattern227 =null;
 10048  
 
 10049  154
 
 10050  758
         Object GRAPH225_tree=null;
 10051  604
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 10052  604
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 10053  758
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10054  
         try {
 10055  154
             // com\\googlecode\\sparkleg\\Sparql.g:336:5: ( GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) )
 10056  154
             // com\\googlecode\\sparkleg\\Sparql.g:336:7: GRAPH varOrIRIref groupGraphPattern
 10057  
             {
 10058  758
             GRAPH225=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern2662);  
 10059  604
             stream_GRAPH.add(GRAPH225);
 10060  
 
 10061  154
 
 10062  758
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern2664);
 10063  758
             varOrIRIref226=varOrIRIref();
 10064  154
 
 10065  604
             state._fsp--;
 10066  
 
 10067  604
             stream_varOrIRIref.add(varOrIRIref226.getTree());
 10068  
 
 10069  758
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern2666);
 10070  758
             groupGraphPattern227=groupGraphPattern();
 10071  
 
 10072  604
             state._fsp--;
 10073  154
 
 10074  758
             stream_groupGraphPattern.add(groupGraphPattern227.getTree());
 10075  
 
 10076  154
             // AST REWRITE
 10077  
             // elements: varOrIRIref, groupGraphPattern, GRAPH
 10078  154
             // token labels: 
 10079  
             // rule labels: retval
 10080  154
             // token list labels: 
 10081  154
             // rule list labels: 
 10082  
             // wildcard labels: 
 10083  758
             retval.tree = root_0;
 10084  604
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10085  154
 
 10086  604
             root_0 = (Object)adaptor.nil();
 10087  
             // 336:43: -> ^( GRAPH varOrIRIref groupGraphPattern )
 10088  
             {
 10089  
                 // com\\googlecode\\sparkleg\\Sparql.g:336:46: ^( GRAPH varOrIRIref groupGraphPattern )
 10090  
                 {
 10091  604
                 Object root_1 = (Object)adaptor.nil();
 10092  604
                 root_1 = (Object)adaptor.becomeRoot(
 10093  
                 stream_GRAPH.nextNode()
 10094  154
                 , root_1);
 10095  154
 
 10096  604
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10097  154
 
 10098  604
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10099  
 
 10100  604
                 adaptor.addChild(root_0, root_1);
 10101  
                 }
 10102  154
 
 10103  154
             }
 10104  
 
 10105  
 
 10106  604
             retval.tree = root_0;
 10107  154
 
 10108  
             }
 10109  154
 
 10110  604
             retval.stop = input.LT(-1);
 10111  154
 
 10112  
 
 10113  604
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10114  604
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10115  
 
 10116  
         }
 10117  154
         catch (RecognitionException re) {
 10118  0
             reportError(re);
 10119  0
             recover(input,re);
 10120  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10121  154
 
 10122  
         }
 10123  
 
 10124  154
         finally {
 10125  154
                 // do for sure before leaving
 10126  604
         }
 10127  604
         return retval;
 10128  
     }
 10129  
     // $ANTLR end "graphGraphPattern"
 10130  
 
 10131  
 
 10132  104
     public static class serviceGraphPattern_return extends ParserRuleReturnScope {
 10133  
         Object tree;
 10134  104
         public Object getTree() { return tree; }
 10135  
     };
 10136  
 
 10137  154
 
 10138  154
     // $ANTLR start "serviceGraphPattern"
 10139  
     // com\\googlecode\\sparkleg\\Sparql.g:339:1: serviceGraphPattern : SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 10140  
     public final SparqlParser.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 10141  104
         SparqlParser.serviceGraphPattern_return retval = new SparqlParser.serviceGraphPattern_return();
 10142  104
         retval.start = input.LT(1);
 10143  26
 
 10144  
 
 10145  104
         Object root_0 = null;
 10146  
 
 10147  104
         Token SERVICE228=null;
 10148  104
         Token SILENT229=null;
 10149  104
         SparqlParser.varOrIRIref_return varOrIRIref230 =null;
 10150  
 
 10151  104
         SparqlParser.groupGraphPattern_return groupGraphPattern231 =null;
 10152  26
 
 10153  26
 
 10154  104
         Object SERVICE228_tree=null;
 10155  104
         Object SILENT229_tree=null;
 10156  130
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 10157  104
         RewriteRuleTokenStream stream_SERVICE=new RewriteRuleTokenStream(adaptor,"token SERVICE");
 10158  130
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 10159  130
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10160  26
         try {
 10161  
             // com\\googlecode\\sparkleg\\Sparql.g:340:5: ( SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 10162  26
             // com\\googlecode\\sparkleg\\Sparql.g:340:7: SERVICE ( SILENT )? varOrIRIref groupGraphPattern
 10163  
             {
 10164  104
             SERVICE228=(Token)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern2693);  
 10165  130
             stream_SERVICE.add(SERVICE228);
 10166  26
 
 10167  26
 
 10168  26
             // com\\googlecode\\sparkleg\\Sparql.g:340:15: ( SILENT )?
 10169  130
             int alt75=2;
 10170  130
             switch ( input.LA(1) ) {
 10171  
                 case SILENT:
 10172  
                     {
 10173  24
                     alt75=1;
 10174  
                     }
 10175  26
                     break;
 10176  26
             }
 10177  
 
 10178  104
             switch (alt75) {
 10179  
                 case 1 :
 10180  26
                     // com\\googlecode\\sparkleg\\Sparql.g:340:15: SILENT
 10181  26
                     {
 10182  24
                     SILENT229=(Token)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern2695);  
 10183  24
                     stream_SILENT.add(SILENT229);
 10184  6
 
 10185  
 
 10186  
                     }
 10187  
                     break;
 10188  
 
 10189  26
             }
 10190  
 
 10191  
 
 10192  104
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern2698);
 10193  110
             varOrIRIref230=varOrIRIref();
 10194  6
 
 10195  104
             state._fsp--;
 10196  
 
 10197  104
             stream_varOrIRIref.add(varOrIRIref230.getTree());
 10198  
 
 10199  104
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern2700);
 10200  104
             groupGraphPattern231=groupGraphPattern();
 10201  
 
 10202  104
             state._fsp--;
 10203  26
 
 10204  130
             stream_groupGraphPattern.add(groupGraphPattern231.getTree());
 10205  
 
 10206  26
             // AST REWRITE
 10207  
             // elements: SERVICE, groupGraphPattern, varOrIRIref, SILENT
 10208  26
             // token labels: 
 10209  
             // rule labels: retval
 10210  26
             // token list labels: 
 10211  26
             // rule list labels: 
 10212  
             // wildcard labels: 
 10213  130
             retval.tree = root_0;
 10214  104
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10215  26
 
 10216  104
             root_0 = (Object)adaptor.nil();
 10217  
             // 340:53: -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10218  
             {
 10219  
                 // com\\googlecode\\sparkleg\\Sparql.g:340:56: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10220  
                 {
 10221  104
                 Object root_1 = (Object)adaptor.nil();
 10222  104
                 root_1 = (Object)adaptor.becomeRoot(
 10223  
                 stream_SERVICE.nextNode()
 10224  26
                 , root_1);
 10225  26
 
 10226  
                 // com\\googlecode\\sparkleg\\Sparql.g:340:66: ( SILENT )?
 10227  130
                 if ( stream_SILENT.hasNext() ) {
 10228  24
                     adaptor.addChild(root_1, 
 10229  
                     stream_SILENT.nextNode()
 10230  
                     );
 10231  
 
 10232  26
                 }
 10233  130
                 stream_SILENT.reset();
 10234  
 
 10235  104
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10236  
 
 10237  104
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10238  26
 
 10239  110
                 adaptor.addChild(root_0, root_1);
 10240  
                 }
 10241  
 
 10242  
             }
 10243  
 
 10244  26
 
 10245  104
             retval.tree = root_0;
 10246  26
 
 10247  
             }
 10248  26
 
 10249  104
             retval.stop = input.LT(-1);
 10250  26
 
 10251  
 
 10252  104
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10253  104
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10254  
 
 10255  
         }
 10256  26
         catch (RecognitionException re) {
 10257  0
             reportError(re);
 10258  0
             recover(input,re);
 10259  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10260  26
 
 10261  
         }
 10262  
 
 10263  26
         finally {
 10264  26
                 // do for sure before leaving
 10265  104
         }
 10266  104
         return retval;
 10267  
     }
 10268  
     // $ANTLR end "serviceGraphPattern"
 10269  
 
 10270  
 
 10271  200
     public static class bind_return extends ParserRuleReturnScope {
 10272  
         Object tree;
 10273  200
         public Object getTree() { return tree; }
 10274  
     };
 10275  
 
 10276  26
 
 10277  26
     // $ANTLR start "bind"
 10278  
     // com\\googlecode\\sparkleg\\Sparql.g:343:1: bind : BIND '(' expression AS var ')' -> ^( BIND expression ^( AS var ) ) ;
 10279  
     public final SparqlParser.bind_return bind() throws RecognitionException {
 10280  200
         SparqlParser.bind_return retval = new SparqlParser.bind_return();
 10281  200
         retval.start = input.LT(1);
 10282  50
 
 10283  
 
 10284  200
         Object root_0 = null;
 10285  
 
 10286  200
         Token BIND232=null;
 10287  200
         Token char_literal233=null;
 10288  200
         Token AS235=null;
 10289  200
         Token char_literal237=null;
 10290  200
         SparqlParser.expression_return expression234 =null;
 10291  50
 
 10292  250
         SparqlParser.var_return var236 =null;
 10293  
 
 10294  
 
 10295  250
         Object BIND232_tree=null;
 10296  200
         Object char_literal233_tree=null;
 10297  250
         Object AS235_tree=null;
 10298  250
         Object char_literal237_tree=null;
 10299  250
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 10300  250
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 10301  250
         RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
 10302  200
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 10303  250
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10304  200
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 10305  
         try {
 10306  50
             // com\\googlecode\\sparkleg\\Sparql.g:344:5: ( BIND '(' expression AS var ')' -> ^( BIND expression ^( AS var ) ) )
 10307  50
             // com\\googlecode\\sparkleg\\Sparql.g:344:7: BIND '(' expression AS var ')'
 10308  50
             {
 10309  250
             BIND232=(Token)match(input,BIND,FOLLOW_BIND_in_bind2734);  
 10310  250
             stream_BIND.add(BIND232);
 10311  50
 
 10312  50
 
 10313  250
             char_literal233=(Token)match(input,209,FOLLOW_209_in_bind2736);  
 10314  250
             stream_209.add(char_literal233);
 10315  50
 
 10316  
 
 10317  200
             pushFollow(FOLLOW_expression_in_bind2738);
 10318  200
             expression234=expression();
 10319  
 
 10320  250
             state._fsp--;
 10321  50
 
 10322  200
             stream_expression.add(expression234.getTree());
 10323  
 
 10324  250
             AS235=(Token)match(input,AS,FOLLOW_AS_in_bind2740);  
 10325  250
             stream_AS.add(AS235);
 10326  
 
 10327  
 
 10328  250
             pushFollow(FOLLOW_var_in_bind2742);
 10329  250
             var236=var();
 10330  
 
 10331  250
             state._fsp--;
 10332  
 
 10333  250
             stream_var.add(var236.getTree());
 10334  
 
 10335  250
             char_literal237=(Token)match(input,210,FOLLOW_210_in_bind2744);  
 10336  250
             stream_210.add(char_literal237);
 10337  
 
 10338  
 
 10339  50
             // AST REWRITE
 10340  50
             // elements: BIND, expression, AS, var
 10341  
             // token labels: 
 10342  50
             // rule labels: retval
 10343  
             // token list labels: 
 10344  50
             // rule list labels: 
 10345  
             // wildcard labels: 
 10346  250
             retval.tree = root_0;
 10347  250
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10348  
 
 10349  200
             root_0 = (Object)adaptor.nil();
 10350  
             // 344:38: -> ^( BIND expression ^( AS var ) )
 10351  
             {
 10352  
                 // com\\googlecode\\sparkleg\\Sparql.g:344:41: ^( BIND expression ^( AS var ) )
 10353  
                 {
 10354  200
                 Object root_1 = (Object)adaptor.nil();
 10355  200
                 root_1 = (Object)adaptor.becomeRoot(
 10356  
                 stream_BIND.nextNode()
 10357  50
                 , root_1);
 10358  50
 
 10359  200
                 adaptor.addChild(root_1, stream_expression.nextTree());
 10360  50
 
 10361  
                 // com\\googlecode\\sparkleg\\Sparql.g:344:59: ^( AS var )
 10362  
                 {
 10363  200
                 Object root_2 = (Object)adaptor.nil();
 10364  200
                 root_2 = (Object)adaptor.becomeRoot(
 10365  50
                 stream_AS.nextNode()
 10366  50
                 , root_2);
 10367  
 
 10368  200
                 adaptor.addChild(root_2, stream_var.nextTree());
 10369  
 
 10370  250
                 adaptor.addChild(root_1, root_2);
 10371  
                 }
 10372  
 
 10373  200
                 adaptor.addChild(root_0, root_1);
 10374  50
                 }
 10375  50
 
 10376  
             }
 10377  
 
 10378  
 
 10379  250
             retval.tree = root_0;
 10380  
 
 10381  50
             }
 10382  
 
 10383  200
             retval.stop = input.LT(-1);
 10384  50
 
 10385  
 
 10386  200
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10387  200
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10388  
 
 10389  
         }
 10390  50
         catch (RecognitionException re) {
 10391  0
             reportError(re);
 10392  0
             recover(input,re);
 10393  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10394  50
 
 10395  
         }
 10396  
 
 10397  50
         finally {
 10398  50
                 // do for sure before leaving
 10399  200
         }
 10400  200
         return retval;
 10401  
     }
 10402  
     // $ANTLR end "bind"
 10403  
 
 10404  
 
 10405  168
     public static class minusGraphPattern_return extends ParserRuleReturnScope {
 10406  
         Object tree;
 10407  168
         public Object getTree() { return tree; }
 10408  
     };
 10409  
 
 10410  50
 
 10411  50
     // $ANTLR start "minusGraphPattern"
 10412  
     // com\\googlecode\\sparkleg\\Sparql.g:347:1: minusGraphPattern : MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) ;
 10413  
     public final SparqlParser.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 10414  168
         SparqlParser.minusGraphPattern_return retval = new SparqlParser.minusGraphPattern_return();
 10415  168
         retval.start = input.LT(1);
 10416  42
 
 10417  
 
 10418  168
         Object root_0 = null;
 10419  
 
 10420  168
         Token MINUS_KEYWORD238=null;
 10421  168
         SparqlParser.groupGraphPattern_return groupGraphPattern239 =null;
 10422  
 
 10423  
 
 10424  168
         Object MINUS_KEYWORD238_tree=null;
 10425  210
         RewriteRuleTokenStream stream_MINUS_KEYWORD=new RewriteRuleTokenStream(adaptor,"token MINUS_KEYWORD");
 10426  210
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10427  
         try {
 10428  
             // com\\googlecode\\sparkleg\\Sparql.g:348:5: ( MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) )
 10429  42
             // com\\googlecode\\sparkleg\\Sparql.g:348:7: MINUS_KEYWORD groupGraphPattern
 10430  
             {
 10431  210
             MINUS_KEYWORD238=(Token)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2781);  
 10432  210
             stream_MINUS_KEYWORD.add(MINUS_KEYWORD238);
 10433  
 
 10434  
 
 10435  210
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern2783);
 10436  210
             groupGraphPattern239=groupGraphPattern();
 10437  42
 
 10438  168
             state._fsp--;
 10439  
 
 10440  168
             stream_groupGraphPattern.add(groupGraphPattern239.getTree());
 10441  
 
 10442  42
             // AST REWRITE
 10443  42
             // elements: groupGraphPattern, MINUS_KEYWORD
 10444  
             // token labels: 
 10445  
             // rule labels: retval
 10446  42
             // token list labels: 
 10447  42
             // rule list labels: 
 10448  
             // wildcard labels: 
 10449  210
             retval.tree = root_0;
 10450  168
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10451  42
 
 10452  168
             root_0 = (Object)adaptor.nil();
 10453  
             // 348:39: -> ^( MINUS_KEYWORD groupGraphPattern )
 10454  
             {
 10455  
                 // com\\googlecode\\sparkleg\\Sparql.g:348:42: ^( MINUS_KEYWORD groupGraphPattern )
 10456  
                 {
 10457  168
                 Object root_1 = (Object)adaptor.nil();
 10458  168
                 root_1 = (Object)adaptor.becomeRoot(
 10459  
                 stream_MINUS_KEYWORD.nextNode()
 10460  42
                 , root_1);
 10461  42
 
 10462  168
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10463  42
 
 10464  168
                 adaptor.addChild(root_0, root_1);
 10465  
                 }
 10466  
 
 10467  
             }
 10468  42
 
 10469  42
 
 10470  168
             retval.tree = root_0;
 10471  
 
 10472  
             }
 10473  42
 
 10474  168
             retval.stop = input.LT(-1);
 10475  42
 
 10476  
 
 10477  168
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10478  168
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10479  
 
 10480  
         }
 10481  42
         catch (RecognitionException re) {
 10482  0
             reportError(re);
 10483  0
             recover(input,re);
 10484  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10485  42
 
 10486  
         }
 10487  
 
 10488  42
         finally {
 10489  42
                 // do for sure before leaving
 10490  168
         }
 10491  168
         return retval;
 10492  
     }
 10493  
     // $ANTLR end "minusGraphPattern"
 10494  
 
 10495  
 
 10496  706
     public static class groupOrUnionGraphPattern_return extends ParserRuleReturnScope {
 10497  
         Object tree;
 10498  706
         public Object getTree() { return tree; }
 10499  
     };
 10500  
 
 10501  42
 
 10502  42
     // $ANTLR start "groupOrUnionGraphPattern"
 10503  
     // com\\googlecode\\sparkleg\\Sparql.g:351:1: groupOrUnionGraphPattern : (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* ;
 10504  
     public final SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 10505  706
         SparqlParser.groupOrUnionGraphPattern_return retval = new SparqlParser.groupOrUnionGraphPattern_return();
 10506  706
         retval.start = input.LT(1);
 10507  178
 
 10508  
 
 10509  706
         Object root_0 = null;
 10510  
 
 10511  706
         Token UNION240=null;
 10512  706
         SparqlParser.groupGraphPattern_return g1 =null;
 10513  
 
 10514  706
         SparqlParser.groupGraphPattern_return g2 =null;
 10515  
 
 10516  178
 
 10517  884
         Object UNION240_tree=null;
 10518  706
         RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
 10519  706
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10520  178
         try {
 10521  
             // com\\googlecode\\sparkleg\\Sparql.g:352:5: ( (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* )
 10522  178
             // com\\googlecode\\sparkleg\\Sparql.g:352:7: (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10523  178
             {
 10524  
             // com\\googlecode\\sparkleg\\Sparql.g:352:7: (g1= groupGraphPattern -> $g1)
 10525  178
             // com\\googlecode\\sparkleg\\Sparql.g:352:8: g1= groupGraphPattern
 10526  
             {
 10527  706
             pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2811);
 10528  884
             g1=groupGraphPattern();
 10529  178
 
 10530  884
             state._fsp--;
 10531  
 
 10532  706
             stream_groupGraphPattern.add(g1.getTree());
 10533  
 
 10534  
             // AST REWRITE
 10535  
             // elements: g1
 10536  
             // token labels: 
 10537  
             // rule labels: retval, g1
 10538  178
             // token list labels: 
 10539  178
             // rule list labels: 
 10540  
             // wildcard labels: 
 10541  884
             retval.tree = root_0;
 10542  706
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10543  884
             RewriteRuleSubtreeStream stream_g1=new RewriteRuleSubtreeStream(adaptor,"rule g1",g1!=null?g1.tree:null);
 10544  
 
 10545  706
             root_0 = (Object)adaptor.nil();
 10546  
             // 352:28: -> $g1
 10547  
             {
 10548  706
                 adaptor.addChild(root_0, stream_g1.nextTree());
 10549  
 
 10550  
             }
 10551  
 
 10552  178
 
 10553  884
             retval.tree = root_0;
 10554  178
 
 10555  
             }
 10556  178
 
 10557  
 
 10558  
             // com\\googlecode\\sparkleg\\Sparql.g:352:35: ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10559  178
             loop76:
 10560  
             do {
 10561  1090
                 int alt76=2;
 10562  1090
                 switch ( input.LA(1) ) {
 10563  
                 case UNION:
 10564  178
                     {
 10565  384
                     alt76=1;
 10566  
                     }
 10567  
                     break;
 10568  
 
 10569  
                 }
 10570  
 
 10571  1090
                 switch (alt76) {
 10572  274
                     case 1 :
 10573  274
                         // com\\googlecode\\sparkleg\\Sparql.g:352:36: ( UNION g2= groupGraphPattern )
 10574  
                         {
 10575  
                         // com\\googlecode\\sparkleg\\Sparql.g:352:36: ( UNION g2= groupGraphPattern )
 10576  96
                         // com\\googlecode\\sparkleg\\Sparql.g:352:37: UNION g2= groupGraphPattern
 10577  
                         {
 10578  384
                         UNION240=(Token)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern2819);  
 10579  384
                         stream_UNION.add(UNION240);
 10580  
 
 10581  
 
 10582  658
                         pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2823);
 10583  384
                         g2=groupGraphPattern();
 10584  
 
 10585  384
                         state._fsp--;
 10586  
 
 10587  384
                         stream_groupGraphPattern.add(g2.getTree());
 10588  
 
 10589  96
                         }
 10590  96
 
 10591  
 
 10592  
                         // AST REWRITE
 10593  96
                         // elements: g2, UNION, groupOrUnionGraphPattern
 10594  96
                         // token labels: 
 10595  
                         // rule labels: retval, g2
 10596  96
                         // token list labels: 
 10597  
                         // rule list labels: 
 10598  96
                         // wildcard labels: 
 10599  384
                         retval.tree = root_0;
 10600  384
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10601  384
                         RewriteRuleSubtreeStream stream_g2=new RewriteRuleSubtreeStream(adaptor,"rule g2",g2!=null?g2.tree:null);
 10602  
 
 10603  384
                         root_0 = (Object)adaptor.nil();
 10604  
                         // 352:65: -> ^( UNION $groupOrUnionGraphPattern $g2)
 10605  
                         {
 10606  
                             // com\\googlecode\\sparkleg\\Sparql.g:352:68: ^( UNION $groupOrUnionGraphPattern $g2)
 10607  
                             {
 10608  384
                             Object root_1 = (Object)adaptor.nil();
 10609  384
                             root_1 = (Object)adaptor.becomeRoot(
 10610  96
                             stream_UNION.nextNode()
 10611  96
                             , root_1);
 10612  96
 
 10613  384
                             adaptor.addChild(root_1, stream_retval.nextTree());
 10614  96
 
 10615  384
                             adaptor.addChild(root_1, stream_g2.nextTree());
 10616  
 
 10617  384
                             adaptor.addChild(root_0, root_1);
 10618  
                             }
 10619  96
 
 10620  96
                         }
 10621  
 
 10622  
 
 10623  384
                         retval.tree = root_0;
 10624  96
 
 10625  
                         }
 10626  480
                         break;
 10627  
 
 10628  96
                     default :
 10629  706
                         break loop76;
 10630  
                 }
 10631  384
             } while (true);
 10632  
 
 10633  
 
 10634  96
             }
 10635  
 
 10636  706
             retval.stop = input.LT(-1);
 10637  96
 
 10638  
 
 10639  706
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10640  884
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10641  
 
 10642  96
         }
 10643  0
         catch (RecognitionException re) {
 10644  0
             reportError(re);
 10645  0
             recover(input,re);
 10646  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10647  178
 
 10648  
         }
 10649  
 
 10650  178
         finally {
 10651  178
                 // do for sure before leaving
 10652  706
         }
 10653  706
         return retval;
 10654  
     }
 10655  
     // $ANTLR end "groupOrUnionGraphPattern"
 10656  
 
 10657  
 
 10658  2342
     public static class filter_return extends ParserRuleReturnScope {
 10659  
         Object tree;
 10660  2342
         public Object getTree() { return tree; }
 10661  
     };
 10662  
 
 10663  178
 
 10664  178
     // $ANTLR start "filter"
 10665  
     // com\\googlecode\\sparkleg\\Sparql.g:355:1: filter : FILTER constraint -> ^( FILTER constraint ) ;
 10666  
     public final SparqlParser.filter_return filter() throws RecognitionException {
 10667  2342
         SparqlParser.filter_return retval = new SparqlParser.filter_return();
 10668  2342
         retval.start = input.LT(1);
 10669  596
 
 10670  
 
 10671  596
         Object root_0 = null;
 10672  
 
 10673  2342
         Token FILTER241=null;
 10674  2342
         SparqlParser.constraint_return constraint242 =null;
 10675  
 
 10676  
 
 10677  2342
         Object FILTER241_tree=null;
 10678  2938
         RewriteRuleTokenStream stream_FILTER=new RewriteRuleTokenStream(adaptor,"token FILTER");
 10679  2938
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 10680  
         try {
 10681  
             // com\\googlecode\\sparkleg\\Sparql.g:356:5: ( FILTER constraint -> ^( FILTER constraint ) )
 10682  596
             // com\\googlecode\\sparkleg\\Sparql.g:356:7: FILTER constraint
 10683  
             {
 10684  2938
             FILTER241=(Token)match(input,FILTER,FOLLOW_FILTER_in_filter2855);  
 10685  2938
             stream_FILTER.add(FILTER241);
 10686  
 
 10687  
 
 10688  2938
             pushFollow(FOLLOW_constraint_in_filter2857);
 10689  2938
             constraint242=constraint();
 10690  596
 
 10691  2342
             state._fsp--;
 10692  
 
 10693  2342
             stream_constraint.add(constraint242.getTree());
 10694  
 
 10695  596
             // AST REWRITE
 10696  596
             // elements: constraint, FILTER
 10697  
             // token labels: 
 10698  
             // rule labels: retval
 10699  596
             // token list labels: 
 10700  596
             // rule list labels: 
 10701  
             // wildcard labels: 
 10702  2938
             retval.tree = root_0;
 10703  2342
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10704  596
 
 10705  2342
             root_0 = (Object)adaptor.nil();
 10706  
             // 356:25: -> ^( FILTER constraint )
 10707  
             {
 10708  
                 // com\\googlecode\\sparkleg\\Sparql.g:356:28: ^( FILTER constraint )
 10709  
                 {
 10710  2342
                 Object root_1 = (Object)adaptor.nil();
 10711  2342
                 root_1 = (Object)adaptor.becomeRoot(
 10712  
                 stream_FILTER.nextNode()
 10713  596
                 , root_1);
 10714  596
 
 10715  2342
                 adaptor.addChild(root_1, stream_constraint.nextTree());
 10716  596
 
 10717  2342
                 adaptor.addChild(root_0, root_1);
 10718  
                 }
 10719  
 
 10720  
             }
 10721  596
 
 10722  596
 
 10723  2342
             retval.tree = root_0;
 10724  
 
 10725  
             }
 10726  596
 
 10727  2342
             retval.stop = input.LT(-1);
 10728  596
 
 10729  
 
 10730  2342
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10731  2342
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10732  
 
 10733  
         }
 10734  596
         catch (RecognitionException re) {
 10735  0
             reportError(re);
 10736  0
             recover(input,re);
 10737  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10738  596
 
 10739  
         }
 10740  
 
 10741  596
         finally {
 10742  596
                 // do for sure before leaving
 10743  2342
         }
 10744  2342
         return retval;
 10745  
     }
 10746  
     // $ANTLR end "filter"
 10747  
 
 10748  
 
 10749  2454
     public static class constraint_return extends ParserRuleReturnScope {
 10750  
         Object tree;
 10751  2454
         public Object getTree() { return tree; }
 10752  
     };
 10753  
 
 10754  596
 
 10755  596
     // $ANTLR start "constraint"
 10756  
     // com\\googlecode\\sparkleg\\Sparql.g:359:1: constraint : ( brackettedExpression | builtInCall | functionCall );
 10757  
     public final SparqlParser.constraint_return constraint() throws RecognitionException {
 10758  2454
         SparqlParser.constraint_return retval = new SparqlParser.constraint_return();
 10759  2454
         retval.start = input.LT(1);
 10760  624
 
 10761  
 
 10762  2454
         Object root_0 = null;
 10763  
 
 10764  2454
         SparqlParser.brackettedExpression_return brackettedExpression243 =null;
 10765  
 
 10766  2454
         SparqlParser.builtInCall_return builtInCall244 =null;
 10767  
 
 10768  2454
         SparqlParser.functionCall_return functionCall245 =null;
 10769  624
 
 10770  624
 
 10771  
 
 10772  
         try {
 10773  624
             // com\\googlecode\\sparkleg\\Sparql.g:360:5: ( brackettedExpression | builtInCall | functionCall )
 10774  2454
             int alt77=3;
 10775  3078
             switch ( input.LA(1) ) {
 10776  
             case 209:
 10777  624
                 {
 10778  1788
                 alt77=1;
 10779  624
                 }
 10780  1788
                 break;
 10781  
             case ABS:
 10782  
             case BNODE:
 10783  
             case BOUND:
 10784  
             case CEIL:
 10785  624
             case COALESCE:
 10786  624
             case CONCAT:
 10787  
             case CONTAINS:
 10788  
             case DATATYPE:
 10789  456
             case DAY:
 10790  
             case ENCODE_FOR_URI:
 10791  456
             case EXISTS:
 10792  
             case FLOOR:
 10793  
             case HOURS:
 10794  
             case IF:
 10795  
             case IRI:
 10796  
             case ISBLANK:
 10797  
             case ISIRI:
 10798  
             case ISLITERAL:
 10799  
             case ISNUMERIC:
 10800  
             case ISURI:
 10801  
             case LANG:
 10802  
             case LANGMATCHES:
 10803  
             case LCASE:
 10804  
             case MD5:
 10805  
             case MINUTES:
 10806  
             case MONTH:
 10807  
             case NOT:
 10808  
             case NOW:
 10809  
             case RAND:
 10810  
             case REGEX:
 10811  
             case REPLACE:
 10812  
             case ROUND:
 10813  
             case SAMETERM:
 10814  
             case SECONDS:
 10815  
             case SHA1:
 10816  
             case SHA256:
 10817  
             case SHA384:
 10818  
             case SHA512:
 10819  
             case STR:
 10820  
             case STRAFTER:
 10821  
             case STRBEFORE:
 10822  
             case STRDT:
 10823  
             case STRENDS:
 10824  
             case STRLANG:
 10825  
             case STRLEN:
 10826  
             case STRSTARTS:
 10827  
             case SUBSTR:
 10828  
             case TIMEZONE:
 10829  
             case TZ:
 10830  
             case UCASE:
 10831  
             case URI:
 10832  
             case YEAR:
 10833  
                 {
 10834  632
                 alt77=2;
 10835  
                 }
 10836  632
                 break;
 10837  
             case IRI_REF:
 10838  
             case PNAME_LN:
 10839  
             case PNAME_NS:
 10840  
                 {
 10841  32
                 alt77=3;
 10842  
                 }
 10843  32
                 break;
 10844  
             default:
 10845  160
                 NoViableAltException nvae =
 10846  
                     new NoViableAltException("", 77, 0, input);
 10847  158
 
 10848  2
                 throw nvae;
 10849  
 
 10850  
             }
 10851  
 
 10852  2460
             switch (alt77) {
 10853  
                 case 1 :
 10854  8
                     // com\\googlecode\\sparkleg\\Sparql.g:360:7: brackettedExpression
 10855  
                     {
 10856  1790
                     root_0 = (Object)adaptor.nil();
 10857  
 
 10858  
 
 10859  1790
                     pushFollow(FOLLOW_brackettedExpression_in_constraint2882);
 10860  1788
                     brackettedExpression243=brackettedExpression();
 10861  
 
 10862  1788
                     state._fsp--;
 10863  622
 
 10864  1788
                     adaptor.addChild(root_0, brackettedExpression243.getTree());
 10865  
 
 10866  
                     }
 10867  2244
                     break;
 10868  
                 case 2 :
 10869  
                     // com\\googlecode\\sparkleg\\Sparql.g:361:7: builtInCall
 10870  456
                     {
 10871  1088
                     root_0 = (Object)adaptor.nil();
 10872  
 
 10873  456
 
 10874  632
                     pushFollow(FOLLOW_builtInCall_in_constraint2890);
 10875  1088
                     builtInCall244=builtInCall();
 10876  
 
 10877  632
                     state._fsp--;
 10878  456
 
 10879  632
                     adaptor.addChild(root_0, builtInCall244.getTree());
 10880  
 
 10881  
                     }
 10882  790
                     break;
 10883  
                 case 3 :
 10884  
                     // com\\googlecode\\sparkleg\\Sparql.g:362:7: functionCall
 10885  158
                     {
 10886  190
                     root_0 = (Object)adaptor.nil();
 10887  
 
 10888  158
 
 10889  32
                     pushFollow(FOLLOW_functionCall_in_constraint2898);
 10890  190
                     functionCall245=functionCall();
 10891  
 
 10892  32
                     state._fsp--;
 10893  158
 
 10894  32
                     adaptor.addChild(root_0, functionCall245.getTree());
 10895  
 
 10896  
                     }
 10897  8
                     break;
 10898  
 
 10899  
             }
 10900  2460
             retval.stop = input.LT(-1);
 10901  8
 
 10902  
 
 10903  2460
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10904  2452
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10905  8
 
 10906  
         }
 10907  2
         catch (RecognitionException re) {
 10908  2
             reportError(re);
 10909  2
             recover(input,re);
 10910  2
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10911  622
 
 10912  
         }
 10913  
 
 10914  622
         finally {
 10915  622
                 // do for sure before leaving
 10916  2454
         }
 10917  2454
         return retval;
 10918  2
     }
 10919  2
     // $ANTLR end "constraint"
 10920  2
 
 10921  2
 
 10922  32
     public static class functionCall_return extends ParserRuleReturnScope {
 10923  
         Object tree;
 10924  32
         public Object getTree() { return tree; }
 10925  
     };
 10926  
 
 10927  624
 
 10928  624
     // $ANTLR start "functionCall"
 10929  
     // com\\googlecode\\sparkleg\\Sparql.g:365:1: functionCall : iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 10930  
     public final SparqlParser.functionCall_return functionCall() throws RecognitionException {
 10931  32
         SparqlParser.functionCall_return retval = new SparqlParser.functionCall_return();
 10932  32
         retval.start = input.LT(1);
 10933  8
 
 10934  
 
 10935  32
         Object root_0 = null;
 10936  
 
 10937  32
         SparqlParser.iriRef_return iriRef246 =null;
 10938  
 
 10939  32
         SparqlParser.argList_return argList247 =null;
 10940  
 
 10941  
 
 10942  40
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 10943  40
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 10944  
         try {
 10945  
             // com\\googlecode\\sparkleg\\Sparql.g:366:5: ( iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 10946  8
             // com\\googlecode\\sparkleg\\Sparql.g:366:7: iriRef argList
 10947  
             {
 10948  40
             pushFollow(FOLLOW_iriRef_in_functionCall2915);
 10949  32
             iriRef246=iriRef();
 10950  8
 
 10951  32
             state._fsp--;
 10952  
 
 10953  40
             stream_iriRef.add(iriRef246.getTree());
 10954  8
 
 10955  32
             pushFollow(FOLLOW_argList_in_functionCall2917);
 10956  32
             argList247=argList();
 10957  
 
 10958  32
             state._fsp--;
 10959  8
 
 10960  40
             stream_argList.add(argList247.getTree());
 10961  
 
 10962  8
             // AST REWRITE
 10963  
             // elements: argList, iriRef
 10964  8
             // token labels: 
 10965  
             // rule labels: retval
 10966  8
             // token list labels: 
 10967  8
             // rule list labels: 
 10968  
             // wildcard labels: 
 10969  40
             retval.tree = root_0;
 10970  32
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10971  8
 
 10972  32
             root_0 = (Object)adaptor.nil();
 10973  
             // 366:22: -> ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10974  
             {
 10975  
                 // com\\googlecode\\sparkleg\\Sparql.g:366:25: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10976  
                 {
 10977  32
                 Object root_1 = (Object)adaptor.nil();
 10978  32
                 root_1 = (Object)adaptor.becomeRoot(
 10979  
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 10980  8
                 , root_1);
 10981  8
 
 10982  32
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 10983  8
 
 10984  
                 // com\\googlecode\\sparkleg\\Sparql.g:366:43: ^( ARG_LIST argList )
 10985  
                 {
 10986  32
                 Object root_2 = (Object)adaptor.nil();
 10987  32
                 root_2 = (Object)adaptor.becomeRoot(
 10988  8
                 (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 10989  8
                 , root_2);
 10990  
 
 10991  32
                 adaptor.addChild(root_2, stream_argList.nextTree());
 10992  
 
 10993  40
                 adaptor.addChild(root_1, root_2);
 10994  
                 }
 10995  
 
 10996  32
                 adaptor.addChild(root_0, root_1);
 10997  8
                 }
 10998  8
 
 10999  
             }
 11000  
 
 11001  
 
 11002  40
             retval.tree = root_0;
 11003  
 
 11004  8
             }
 11005  
 
 11006  32
             retval.stop = input.LT(-1);
 11007  8
 
 11008  
 
 11009  32
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11010  32
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11011  
 
 11012  
         }
 11013  8
         catch (RecognitionException re) {
 11014  0
             reportError(re);
 11015  0
             recover(input,re);
 11016  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11017  8
 
 11018  
         }
 11019  
 
 11020  8
         finally {
 11021  8
                 // do for sure before leaving
 11022  32
         }
 11023  32
         return retval;
 11024  
     }
 11025  
     // $ANTLR end "functionCall"
 11026  
 
 11027  
 
 11028  416
     public static class argList_return extends ParserRuleReturnScope {
 11029  
         Object tree;
 11030  416
         public Object getTree() { return tree; }
 11031  
     };
 11032  
 
 11033  8
 
 11034  8
     // $ANTLR start "argList"
 11035  
     // com\\googlecode\\sparkleg\\Sparql.g:369:1: argList : ( nil -> nil | '(' ( DISTINCT )? expression ( ',' expression )* ')' -> ( DISTINCT )? ( expression )* );
 11036  
     public final SparqlParser.argList_return argList() throws RecognitionException {
 11037  416
         SparqlParser.argList_return retval = new SparqlParser.argList_return();
 11038  416
         retval.start = input.LT(1);
 11039  56
 
 11040  
 
 11041  416
         Object root_0 = null;
 11042  
 
 11043  416
         Token char_literal249=null;
 11044  416
         Token DISTINCT250=null;
 11045  416
         Token char_literal252=null;
 11046  416
         Token char_literal254=null;
 11047  416
         SparqlParser.nil_return nil248 =null;
 11048  56
 
 11049  472
         SparqlParser.expression_return expression251 =null;
 11050  
 
 11051  416
         SparqlParser.expression_return expression253 =null;
 11052  56
 
 11053  
 
 11054  472
         Object char_literal249_tree=null;
 11055  472
         Object DISTINCT250_tree=null;
 11056  472
         Object char_literal252_tree=null;
 11057  472
         Object char_literal254_tree=null;
 11058  472
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 11059  416
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 11060  472
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 11061  416
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 11062  472
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11063  416
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11064  
         try {
 11065  56
             // com\\googlecode\\sparkleg\\Sparql.g:370:5: ( nil -> nil | '(' ( DISTINCT )? expression ( ',' expression )* ')' -> ( DISTINCT )? ( expression )* )
 11066  472
             int alt80=2;
 11067  472
             switch ( input.LA(1) ) {
 11068  56
             case 209:
 11069  56
                 {
 11070  472
                 switch ( input.LA(2) ) {
 11071  56
                 case 210:
 11072  56
                     {
 11073  272
                     alt80=1;
 11074  56
                     }
 11075  216
                     break;
 11076  
                 case ABS:
 11077  56
                 case AVG:
 11078  56
                 case BNODE:
 11079  
                 case BOUND:
 11080  
                 case CEIL:
 11081  56
                 case COALESCE:
 11082  
                 case CONCAT:
 11083  
                 case CONTAINS:
 11084  6
                 case COUNT:
 11085  
                 case DATATYPE:
 11086  6
                 case DAY:
 11087  
                 case DECIMAL:
 11088  
                 case DECIMAL_NEGATIVE:
 11089  
                 case DECIMAL_POSITIVE:
 11090  
                 case DISTINCT:
 11091  
                 case DOUBLE:
 11092  
                 case DOUBLE_NEGATIVE:
 11093  
                 case DOUBLE_POSITIVE:
 11094  
                 case ENCODE_FOR_URI:
 11095  
                 case EXISTS:
 11096  
                 case FALSE:
 11097  
                 case FLOOR:
 11098  
                 case GROUP_CONCAT:
 11099  
                 case HOURS:
 11100  
                 case IF:
 11101  
                 case INTEGER:
 11102  
                 case INTEGER_NEGATIVE:
 11103  
                 case INTEGER_POSITIVE:
 11104  
                 case IRI:
 11105  
                 case IRI_REF:
 11106  
                 case ISBLANK:
 11107  
                 case ISIRI:
 11108  
                 case ISLITERAL:
 11109  
                 case ISNUMERIC:
 11110  
                 case ISURI:
 11111  
                 case LANG:
 11112  
                 case LANGMATCHES:
 11113  
                 case LCASE:
 11114  
                 case MAX:
 11115  
                 case MD5:
 11116  
                 case MIN:
 11117  
                 case MINUS:
 11118  
                 case MINUTES:
 11119  
                 case MONTH:
 11120  
                 case NEGATION:
 11121  
                 case NOT:
 11122  
                 case NOW:
 11123  
                 case PLUS:
 11124  
                 case PNAME_LN:
 11125  
                 case PNAME_NS:
 11126  
                 case RAND:
 11127  
                 case REGEX:
 11128  
                 case REPLACE:
 11129  
                 case ROUND:
 11130  
                 case SAMETERM:
 11131  
                 case SAMPLE:
 11132  
                 case SECONDS:
 11133  
                 case SHA1:
 11134  
                 case SHA256:
 11135  
                 case SHA384:
 11136  
                 case SHA512:
 11137  
                 case STR:
 11138  
                 case STRAFTER:
 11139  
                 case STRBEFORE:
 11140  
                 case STRDT:
 11141  
                 case STRENDS:
 11142  
                 case STRING_LITERAL1:
 11143  
                 case STRING_LITERAL2:
 11144  
                 case STRING_LITERAL_LONG1:
 11145  
                 case STRING_LITERAL_LONG2:
 11146  
                 case STRLANG:
 11147  
                 case STRLEN:
 11148  
                 case STRSTARTS:
 11149  
                 case SUBSTR:
 11150  
                 case SUM:
 11151  
                 case TIMEZONE:
 11152  
                 case TRUE:
 11153  
                 case TZ:
 11154  
                 case UCASE:
 11155  
                 case URI:
 11156  
                 case VAR1:
 11157  
                 case VAR2:
 11158  
                 case YEAR:
 11159  
                 case 209:
 11160  
                     {
 11161  200
                     alt80=2;
 11162  
                     }
 11163  200
                     break;
 11164  
                 default:
 11165  0
                     NoViableAltException nvae =
 11166  
                         new NoViableAltException("", 80, 1, input);
 11167  
 
 11168  0
                     throw nvae;
 11169  
 
 11170  
                 }
 11171  
 
 11172  50
                 }
 11173  416
                 break;
 11174  50
             default:
 11175  0
                 NoViableAltException nvae =
 11176  
                     new NoViableAltException("", 80, 0, input);
 11177  
 
 11178  0
                 throw nvae;
 11179  
 
 11180  
             }
 11181  
 
 11182  416
             switch (alt80) {
 11183  
                 case 1 :
 11184  56
                     // com\\googlecode\\sparkleg\\Sparql.g:370:7: nil
 11185  
                     {
 11186  216
                     pushFollow(FOLLOW_nil_in_argList2948);
 11187  216
                     nil248=nil();
 11188  
 
 11189  216
                     state._fsp--;
 11190  
 
 11191  216
                     stream_nil.add(nil248.getTree());
 11192  
 
 11193  56
                     // AST REWRITE
 11194  
                     // elements: nil
 11195  
                     // token labels: 
 11196  
                     // rule labels: retval
 11197  6
                     // token list labels: 
 11198  6
                     // rule list labels: 
 11199  
                     // wildcard labels: 
 11200  222
                     retval.tree = root_0;
 11201  216
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11202  6
 
 11203  216
                     root_0 = (Object)adaptor.nil();
 11204  
                     // 370:11: -> nil
 11205  
                     {
 11206  216
                         adaptor.addChild(root_0, stream_nil.nextTree());
 11207  
 
 11208  
                     }
 11209  
 
 11210  
 
 11211  222
                     retval.tree = root_0;
 11212  6
 
 11213  
                     }
 11214  222
                     break;
 11215  
                 case 2 :
 11216  
                     // com\\googlecode\\sparkleg\\Sparql.g:371:7: '(' ( DISTINCT )? expression ( ',' expression )* ')'
 11217  6
                     {
 11218  200
                     char_literal249=(Token)match(input,209,FOLLOW_209_in_argList2960);  
 11219  200
                     stream_209.add(char_literal249);
 11220  
 
 11221  
 
 11222  6
                     // com\\googlecode\\sparkleg\\Sparql.g:371:11: ( DISTINCT )?
 11223  200
                     int alt78=2;
 11224  200
                     switch ( input.LA(1) ) {
 11225  6
                         case DISTINCT:
 11226  
                             {
 11227  0
                             alt78=1;
 11228  
                             }
 11229  50
                             break;
 11230  50
                     }
 11231  
 
 11232  200
                     switch (alt78) {
 11233  
                         case 1 :
 11234  50
                             // com\\googlecode\\sparkleg\\Sparql.g:371:11: DISTINCT
 11235  50
                             {
 11236  0
                             DISTINCT250=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList2962);  
 11237  0
                             stream_DISTINCT.add(DISTINCT250);
 11238  
 
 11239  
 
 11240  
                             }
 11241  
                             break;
 11242  
 
 11243  50
                     }
 11244  
 
 11245  
 
 11246  200
                     pushFollow(FOLLOW_expression_in_argList2965);
 11247  200
                     expression251=expression();
 11248  
 
 11249  200
                     state._fsp--;
 11250  
 
 11251  200
                     stream_expression.add(expression251.getTree());
 11252  
 
 11253  
                     // com\\googlecode\\sparkleg\\Sparql.g:371:32: ( ',' expression )*
 11254  
                     loop79:
 11255  
                     do {
 11256  272
                         int alt79=2;
 11257  322
                         switch ( input.LA(1) ) {
 11258  50
                         case 211:
 11259  
                             {
 11260  122
                             alt79=1;
 11261  
                             }
 11262  50
                             break;
 11263  
 
 11264  
                         }
 11265  
 
 11266  272
                         switch (alt79) {
 11267  68
                             case 1 :
 11268  68
                                 // com\\googlecode\\sparkleg\\Sparql.g:371:33: ',' expression
 11269  
                                 {
 11270  72
                                 char_literal252=(Token)match(input,211,FOLLOW_211_in_argList2968);  
 11271  90
                                 stream_211.add(char_literal252);
 11272  
 
 11273  
 
 11274  72
                                 pushFollow(FOLLOW_expression_in_argList2970);
 11275  72
                                 expression253=expression();
 11276  
 
 11277  140
                                 state._fsp--;
 11278  
 
 11279  72
                                 stream_expression.add(expression253.getTree());
 11280  
 
 11281  18
                                 }
 11282  90
                                 break;
 11283  
 
 11284  
                             default :
 11285  218
                                 break loop79;
 11286  18
                         }
 11287  72
                     } while (true);
 11288  18
 
 11289  
 
 11290  218
                     char_literal254=(Token)match(input,210,FOLLOW_210_in_argList2974);  
 11291  200
                     stream_210.add(char_literal254);
 11292  
 
 11293  18
 
 11294  
                     // AST REWRITE
 11295  
                     // elements: DISTINCT, expression
 11296  50
                     // token labels: 
 11297  
                     // rule labels: retval
 11298  18
                     // token list labels: 
 11299  
                     // rule list labels: 
 11300  
                     // wildcard labels: 
 11301  250
                     retval.tree = root_0;
 11302  250
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11303  
 
 11304  200
                     root_0 = (Object)adaptor.nil();
 11305  
                     // 371:54: -> ( DISTINCT )? ( expression )*
 11306  
                     {
 11307  
                         // com\\googlecode\\sparkleg\\Sparql.g:371:57: ( DISTINCT )?
 11308  200
                         if ( stream_DISTINCT.hasNext() ) {
 11309  0
                             adaptor.addChild(root_0, 
 11310  
                             stream_DISTINCT.nextNode()
 11311  
                             );
 11312  50
 
 11313  50
                         }
 11314  200
                         stream_DISTINCT.reset();
 11315  50
 
 11316  
                         // com\\googlecode\\sparkleg\\Sparql.g:371:67: ( expression )*
 11317  472
                         while ( stream_expression.hasNext() ) {
 11318  272
                             adaptor.addChild(root_0, stream_expression.nextTree());
 11319  50
 
 11320  
                         }
 11321  200
                         stream_expression.reset();
 11322  
 
 11323  
                     }
 11324  
 
 11325  50
 
 11326  200
                     retval.tree = root_0;
 11327  
 
 11328  118
                     }
 11329  68
                     break;
 11330  
 
 11331  
             }
 11332  466
             retval.stop = input.LT(-1);
 11333  
 
 11334  
 
 11335  416
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11336  416
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11337  50
 
 11338  
         }
 11339  0
         catch (RecognitionException re) {
 11340  0
             reportError(re);
 11341  0
             recover(input,re);
 11342  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11343  56
 
 11344  
         }
 11345  
 
 11346  56
         finally {
 11347  56
                 // do for sure before leaving
 11348  416
         }
 11349  416
         return retval;
 11350  
     }
 11351  
     // $ANTLR end "argList"
 11352  
 
 11353  
 
 11354  120
     public static class expressionList_return extends ParserRuleReturnScope {
 11355  
         Object tree;
 11356  120
         public Object getTree() { return tree; }
 11357  
     };
 11358  
 
 11359  56
 
 11360  56
     // $ANTLR start "expressionList"
 11361  
     // com\\googlecode\\sparkleg\\Sparql.g:374:1: expressionList : ( nil | '(' expression ( ',' expression )* ')' ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) ;
 11362  
     public final SparqlParser.expressionList_return expressionList() throws RecognitionException {
 11363  120
         SparqlParser.expressionList_return retval = new SparqlParser.expressionList_return();
 11364  120
         retval.start = input.LT(1);
 11365  30
 
 11366  
 
 11367  120
         Object root_0 = null;
 11368  
 
 11369  120
         Token char_literal256=null;
 11370  120
         Token char_literal258=null;
 11371  120
         Token char_literal260=null;
 11372  120
         SparqlParser.nil_return nil255 =null;
 11373  
 
 11374  150
         SparqlParser.expression_return expression257 =null;
 11375  30
 
 11376  120
         SparqlParser.expression_return expression259 =null;
 11377  
 
 11378  30
 
 11379  120
         Object char_literal256_tree=null;
 11380  150
         Object char_literal258_tree=null;
 11381  150
         Object char_literal260_tree=null;
 11382  150
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 11383  150
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 11384  120
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 11385  150
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11386  120
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11387  30
         try {
 11388  
             // com\\googlecode\\sparkleg\\Sparql.g:375:5: ( ( nil | '(' expression ( ',' expression )* ')' ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) )
 11389  
             // com\\googlecode\\sparkleg\\Sparql.g:375:7: ( nil | '(' expression ( ',' expression )* ')' )
 11390  30
             {
 11391  30
             // com\\googlecode\\sparkleg\\Sparql.g:375:7: ( nil | '(' expression ( ',' expression )* ')' )
 11392  150
             int alt82=2;
 11393  150
             switch ( input.LA(1) ) {
 11394  30
             case 209:
 11395  30
                 {
 11396  150
                 switch ( input.LA(2) ) {
 11397  30
                 case 210:
 11398  
                     {
 11399  8
                     alt82=1;
 11400  
                     }
 11401  8
                     break;
 11402  
                 case ABS:
 11403  30
                 case AVG:
 11404  30
                 case BNODE:
 11405  
                 case BOUND:
 11406  
                 case CEIL:
 11407  30
                 case COALESCE:
 11408  
                 case CONCAT:
 11409  
                 case CONTAINS:
 11410  2
                 case COUNT:
 11411  
                 case DATATYPE:
 11412  2
                 case DAY:
 11413  
                 case DECIMAL:
 11414  
                 case DECIMAL_NEGATIVE:
 11415  
                 case DECIMAL_POSITIVE:
 11416  
                 case DOUBLE:
 11417  
                 case DOUBLE_NEGATIVE:
 11418  
                 case DOUBLE_POSITIVE:
 11419  
                 case ENCODE_FOR_URI:
 11420  
                 case EXISTS:
 11421  
                 case FALSE:
 11422  
                 case FLOOR:
 11423  
                 case GROUP_CONCAT:
 11424  
                 case HOURS:
 11425  
                 case IF:
 11426  
                 case INTEGER:
 11427  
                 case INTEGER_NEGATIVE:
 11428  
                 case INTEGER_POSITIVE:
 11429  
                 case IRI:
 11430  
                 case IRI_REF:
 11431  
                 case ISBLANK:
 11432  
                 case ISIRI:
 11433  
                 case ISLITERAL:
 11434  
                 case ISNUMERIC:
 11435  
                 case ISURI:
 11436  
                 case LANG:
 11437  
                 case LANGMATCHES:
 11438  
                 case LCASE:
 11439  
                 case MAX:
 11440  
                 case MD5:
 11441  
                 case MIN:
 11442  
                 case MINUS:
 11443  
                 case MINUTES:
 11444  
                 case MONTH:
 11445  
                 case NEGATION:
 11446  
                 case NOT:
 11447  
                 case NOW:
 11448  
                 case PLUS:
 11449  
                 case PNAME_LN:
 11450  
                 case PNAME_NS:
 11451  
                 case RAND:
 11452  
                 case REGEX:
 11453  
                 case REPLACE:
 11454  
                 case ROUND:
 11455  
                 case SAMETERM:
 11456  
                 case SAMPLE:
 11457  
                 case SECONDS:
 11458  
                 case SHA1:
 11459  
                 case SHA256:
 11460  
                 case SHA384:
 11461  
                 case SHA512:
 11462  
                 case STR:
 11463  
                 case STRAFTER:
 11464  
                 case STRBEFORE:
 11465  
                 case STRDT:
 11466  
                 case STRENDS:
 11467  
                 case STRING_LITERAL1:
 11468  
                 case STRING_LITERAL2:
 11469  
                 case STRING_LITERAL_LONG1:
 11470  
                 case STRING_LITERAL_LONG2:
 11471  
                 case STRLANG:
 11472  
                 case STRLEN:
 11473  
                 case STRSTARTS:
 11474  
                 case SUBSTR:
 11475  
                 case SUM:
 11476  
                 case TIMEZONE:
 11477  
                 case TRUE:
 11478  
                 case TZ:
 11479  
                 case UCASE:
 11480  
                 case URI:
 11481  
                 case VAR1:
 11482  
                 case VAR2:
 11483  
                 case YEAR:
 11484  
                 case 209:
 11485  
                     {
 11486  112
                     alt82=2;
 11487  
                     }
 11488  112
                     break;
 11489  
                 default:
 11490  0
                     NoViableAltException nvae =
 11491  
                         new NoViableAltException("", 82, 1, input);
 11492  
 
 11493  0
                     throw nvae;
 11494  
 
 11495  
                 }
 11496  
 
 11497  28
                 }
 11498  120
                 break;
 11499  28
             default:
 11500  0
                 NoViableAltException nvae =
 11501  
                     new NoViableAltException("", 82, 0, input);
 11502  
 
 11503  0
                 throw nvae;
 11504  
 
 11505  
             }
 11506  
 
 11507  120
             switch (alt82) {
 11508  
                 case 1 :
 11509  30
                     // com\\googlecode\\sparkleg\\Sparql.g:375:8: nil
 11510  
                     {
 11511  8
                     pushFollow(FOLLOW_nil_in_expressionList3000);
 11512  8
                     nil255=nil();
 11513  
 
 11514  8
                     state._fsp--;
 11515  
 
 11516  8
                     stream_nil.add(nil255.getTree());
 11517  
 
 11518  30
                     }
 11519  8
                     break;
 11520  
                 case 2 :
 11521  
                     // com\\googlecode\\sparkleg\\Sparql.g:375:14: '(' expression ( ',' expression )* ')'
 11522  2
                     {
 11523  114
                     char_literal256=(Token)match(input,209,FOLLOW_209_in_expressionList3004);  
 11524  112
                     stream_209.add(char_literal256);
 11525  2
 
 11526  
 
 11527  114
                     pushFollow(FOLLOW_expression_in_expressionList3006);
 11528  112
                     expression257=expression();
 11529  
 
 11530  114
                     state._fsp--;
 11531  
 
 11532  112
                     stream_expression.add(expression257.getTree());
 11533  
 
 11534  28
                     // com\\googlecode\\sparkleg\\Sparql.g:375:29: ( ',' expression )*
 11535  28
                     loop81:
 11536  
                     do {
 11537  248
                         int alt81=2;
 11538  276
                         switch ( input.LA(1) ) {
 11539  28
                         case 211:
 11540  
                             {
 11541  164
                             alt81=1;
 11542  
                             }
 11543  28
                             break;
 11544  
 
 11545  
                         }
 11546  
 
 11547  248
                         switch (alt81) {
 11548  62
                             case 1 :
 11549  62
                                 // com\\googlecode\\sparkleg\\Sparql.g:375:30: ',' expression
 11550  
                                 {
 11551  136
                                 char_literal258=(Token)match(input,211,FOLLOW_211_in_expressionList3009);  
 11552  170
                                 stream_211.add(char_literal258);
 11553  
 
 11554  
 
 11555  136
                                 pushFollow(FOLLOW_expression_in_expressionList3011);
 11556  136
                                 expression259=expression();
 11557  
 
 11558  198
                                 state._fsp--;
 11559  
 
 11560  136
                                 stream_expression.add(expression259.getTree());
 11561  
 
 11562  34
                                 }
 11563  170
                                 break;
 11564  
 
 11565  
                             default :
 11566  146
                                 break loop81;
 11567  34
                         }
 11568  136
                     } while (true);
 11569  34
 
 11570  
 
 11571  146
                     char_literal260=(Token)match(input,210,FOLLOW_210_in_expressionList3015);  
 11572  112
                     stream_210.add(char_literal260);
 11573  
 
 11574  34
 
 11575  
                     }
 11576  
                     break;
 11577  28
 
 11578  
             }
 11579  34
 
 11580  
 
 11581  
             // AST REWRITE
 11582  28
             // elements: expression, nil
 11583  28
             // token labels: 
 11584  
             // rule labels: retval
 11585  
             // token list labels: 
 11586  
             // rule list labels: 
 11587  
             // wildcard labels: 
 11588  120
             retval.tree = root_0;
 11589  120
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11590  
 
 11591  120
             root_0 = (Object)adaptor.nil();
 11592  
             // 375:52: -> ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11593  
             {
 11594  
                 // com\\googlecode\\sparkleg\\Sparql.g:375:55: ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11595  
                 {
 11596  120
                 Object root_1 = (Object)adaptor.nil();
 11597  120
                 root_1 = (Object)adaptor.becomeRoot(
 11598  
                 (Object)adaptor.create(EXPRESSION_LIST, "EXPRESSION_LIST")
 11599  30
                 , root_1);
 11600  30
 
 11601  
                 // com\\googlecode\\sparkleg\\Sparql.g:375:73: ( nil )*
 11602  158
                 while ( stream_nil.hasNext() ) {
 11603  8
                     adaptor.addChild(root_1, stream_nil.nextTree());
 11604  
 
 11605  
                 }
 11606  120
                 stream_nil.reset();
 11607  30
 
 11608  30
                 // com\\googlecode\\sparkleg\\Sparql.g:375:78: ( expression )*
 11609  368
                 while ( stream_expression.hasNext() ) {
 11610  248
                     adaptor.addChild(root_1, stream_expression.nextTree());
 11611  
 
 11612  
                 }
 11613  152
                 stream_expression.reset();
 11614  2
 
 11615  120
                 adaptor.addChild(root_0, root_1);
 11616  
                 }
 11617  30
 
 11618  
             }
 11619  
 
 11620  92
 
 11621  182
             retval.tree = root_0;
 11622  
 
 11623  
             }
 11624  30
 
 11625  120
             retval.stop = input.LT(-1);
 11626  30
 
 11627  
 
 11628  120
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11629  120
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11630  
 
 11631  
         }
 11632  30
         catch (RecognitionException re) {
 11633  0
             reportError(re);
 11634  0
             recover(input,re);
 11635  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11636  30
 
 11637  
         }
 11638  
 
 11639  30
         finally {
 11640  30
                 // do for sure before leaving
 11641  120
         }
 11642  120
         return retval;
 11643  
     }
 11644  
     // $ANTLR end "expressionList"
 11645  
 
 11646  
 
 11647  216
     public static class constructTemplate_return extends ParserRuleReturnScope {
 11648  
         Object tree;
 11649  216
         public Object getTree() { return tree; }
 11650  
     };
 11651  
 
 11652  30
 
 11653  30
     // $ANTLR start "constructTemplate"
 11654  
     // com\\googlecode\\sparkleg\\Sparql.g:378:1: constructTemplate : '{' ( constructTriples )? '}' -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 11655  
     public final SparqlParser.constructTemplate_return constructTemplate() throws RecognitionException {
 11656  216
         SparqlParser.constructTemplate_return retval = new SparqlParser.constructTemplate_return();
 11657  216
         retval.start = input.LT(1);
 11658  54
 
 11659  
 
 11660  216
         Object root_0 = null;
 11661  
 
 11662  216
         Token char_literal261=null;
 11663  216
         Token char_literal263=null;
 11664  216
         SparqlParser.constructTriples_return constructTriples262 =null;
 11665  
 
 11666  
 
 11667  270
         Object char_literal261_tree=null;
 11668  270
         Object char_literal263_tree=null;
 11669  216
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 11670  216
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 11671  270
         RewriteRuleSubtreeStream stream_constructTriples=new RewriteRuleSubtreeStream(adaptor,"rule constructTriples");
 11672  
         try {
 11673  54
             // com\\googlecode\\sparkleg\\Sparql.g:379:5: ( '{' ( constructTriples )? '}' -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 11674  54
             // com\\googlecode\\sparkleg\\Sparql.g:379:7: '{' ( constructTriples )? '}'
 11675  54
             {
 11676  216
             char_literal261=(Token)match(input,216,FOLLOW_216_in_constructTemplate3046);  
 11677  216
             stream_216.add(char_literal261);
 11678  54
 
 11679  54
 
 11680  54
             // com\\googlecode\\sparkleg\\Sparql.g:379:11: ( constructTriples )?
 11681  270
             int alt83=2;
 11682  270
             switch ( input.LA(1) ) {
 11683  
                 case BLANK_NODE_LABEL:
 11684  
                 case DECIMAL:
 11685  
                 case DECIMAL_NEGATIVE:
 11686  
                 case DECIMAL_POSITIVE:
 11687  54
                 case DOUBLE:
 11688  54
                 case DOUBLE_NEGATIVE:
 11689  
                 case DOUBLE_POSITIVE:
 11690  
                 case FALSE:
 11691  
                 case INTEGER:
 11692  54
                 case INTEGER_NEGATIVE:
 11693  54
                 case INTEGER_POSITIVE:
 11694  
                 case IRI_REF:
 11695  
                 case PNAME_LN:
 11696  
                 case PNAME_NS:
 11697  
                 case STRING_LITERAL1:
 11698  
                 case STRING_LITERAL2:
 11699  
                 case STRING_LITERAL_LONG1:
 11700  
                 case STRING_LITERAL_LONG2:
 11701  
                 case TRUE:
 11702  
                 case VAR1:
 11703  
                 case VAR2:
 11704  
                 case 209:
 11705  
                 case 213:
 11706  
                     {
 11707  208
                     alt83=1;
 11708  
                     }
 11709  
                     break;
 11710  
             }
 11711  
 
 11712  216
             switch (alt83) {
 11713  
                 case 1 :
 11714  
                     // com\\googlecode\\sparkleg\\Sparql.g:379:11: constructTriples
 11715  
                     {
 11716  208
                     pushFollow(FOLLOW_constructTriples_in_constructTemplate3048);
 11717  208
                     constructTriples262=constructTriples();
 11718  52
 
 11719  208
                     state._fsp--;
 11720  
 
 11721  208
                     stream_constructTriples.add(constructTriples262.getTree());
 11722  
 
 11723  54
                     }
 11724  
                     break;
 11725  
 
 11726  
             }
 11727  52
 
 11728  52
 
 11729  216
             char_literal263=(Token)match(input,218,FOLLOW_218_in_constructTemplate3051);  
 11730  268
             stream_218.add(char_literal263);
 11731  
 
 11732  52
 
 11733  
             // AST REWRITE
 11734  
             // elements: constructTriples
 11735  
             // token labels: 
 11736  
             // rule labels: retval
 11737  
             // token list labels: 
 11738  
             // rule list labels: 
 11739  
             // wildcard labels: 
 11740  270
             retval.tree = root_0;
 11741  270
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11742  
 
 11743  216
             root_0 = (Object)adaptor.nil();
 11744  
             // 379:33: -> ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11745  
             {
 11746  
                 // com\\googlecode\\sparkleg\\Sparql.g:379:36: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11747  
                 {
 11748  216
                 Object root_1 = (Object)adaptor.nil();
 11749  216
                 root_1 = (Object)adaptor.becomeRoot(
 11750  
                 (Object)adaptor.create(CONSTRUCT_TRIPLES, "CONSTRUCT_TRIPLES")
 11751  54
                 , root_1);
 11752  54
 
 11753  
                 // com\\googlecode\\sparkleg\\Sparql.g:379:56: ( constructTriples )?
 11754  270
                 if ( stream_constructTriples.hasNext() ) {
 11755  208
                     adaptor.addChild(root_1, stream_constructTriples.nextTree());
 11756  
 
 11757  
                 }
 11758  216
                 stream_constructTriples.reset();
 11759  54
 
 11760  270
                 adaptor.addChild(root_0, root_1);
 11761  
                 }
 11762  
 
 11763  
             }
 11764  
 
 11765  54
 
 11766  268
             retval.tree = root_0;
 11767  
 
 11768  
             }
 11769  54
 
 11770  216
             retval.stop = input.LT(-1);
 11771  54
 
 11772  
 
 11773  216
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11774  216
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11775  
 
 11776  
         }
 11777  54
         catch (RecognitionException re) {
 11778  0
             reportError(re);
 11779  0
             recover(input,re);
 11780  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11781  54
 
 11782  
         }
 11783  
 
 11784  54
         finally {
 11785  54
                 // do for sure before leaving
 11786  216
         }
 11787  216
         return retval;
 11788  
     }
 11789  
     // $ANTLR end "constructTemplate"
 11790  
 
 11791  
 
 11792  208
     public static class constructTriples_return extends ParserRuleReturnScope {
 11793  
         Object tree;
 11794  208
         public Object getTree() { return tree; }
 11795  
     };
 11796  
 
 11797  54
 
 11798  54
     // $ANTLR start "constructTriples"
 11799  
     // com\\googlecode\\sparkleg\\Sparql.g:382:1: constructTriples : triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ( triplesSameSubject )+ ;
 11800  
     public final SparqlParser.constructTriples_return constructTriples() throws RecognitionException {
 11801  208
         SparqlParser.constructTriples_return retval = new SparqlParser.constructTriples_return();
 11802  208
         retval.start = input.LT(1);
 11803  52
 
 11804  
 
 11805  208
         Object root_0 = null;
 11806  
 
 11807  208
         Token char_literal265=null;
 11808  208
         Token char_literal267=null;
 11809  208
         SparqlParser.triplesSameSubject_return triplesSameSubject264 =null;
 11810  
 
 11811  208
         SparqlParser.triplesSameSubject_return triplesSameSubject266 =null;
 11812  52
 
 11813  52
 
 11814  208
         Object char_literal265_tree=null;
 11815  208
         Object char_literal267_tree=null;
 11816  260
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 11817  208
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 11818  52
         try {
 11819  52
             // com\\googlecode\\sparkleg\\Sparql.g:383:5: ( triplesSameSubject ( '.' triplesSameSubject )* ( '.' )? -> ( triplesSameSubject )+ )
 11820  52
             // com\\googlecode\\sparkleg\\Sparql.g:383:7: triplesSameSubject ( '.' triplesSameSubject )* ( '.' )?
 11821  
             {
 11822  260
             pushFollow(FOLLOW_triplesSameSubject_in_constructTriples3077);
 11823  208
             triplesSameSubject264=triplesSameSubject();
 11824  
 
 11825  260
             state._fsp--;
 11826  52
 
 11827  260
             stream_triplesSameSubject.add(triplesSameSubject264.getTree());
 11828  52
 
 11829  
             // com\\googlecode\\sparkleg\\Sparql.g:383:26: ( '.' triplesSameSubject )*
 11830  
             loop84:
 11831  
             do {
 11832  272
                 int alt84=2;
 11833  324
                 switch ( input.LA(1) ) {
 11834  52
                 case DOT:
 11835  
                     {
 11836  226
                     switch ( input.LA(2) ) {
 11837  
                     case BLANK_NODE_LABEL:
 11838  52
                     case DECIMAL:
 11839  
                     case DECIMAL_NEGATIVE:
 11840  
                     case DECIMAL_POSITIVE:
 11841  
                     case DOUBLE:
 11842  
                     case DOUBLE_NEGATIVE:
 11843  68
                     case DOUBLE_POSITIVE:
 11844  68
                     case FALSE:
 11845  
                     case INTEGER:
 11846  
                     case INTEGER_NEGATIVE:
 11847  30
                     case INTEGER_POSITIVE:
 11848  
                     case IRI_REF:
 11849  
                     case PNAME_LN:
 11850  
                     case PNAME_NS:
 11851  
                     case STRING_LITERAL1:
 11852  
                     case STRING_LITERAL2:
 11853  
                     case STRING_LITERAL_LONG1:
 11854  
                     case STRING_LITERAL_LONG2:
 11855  
                     case TRUE:
 11856  
                     case VAR1:
 11857  
                     case VAR2:
 11858  
                     case 209:
 11859  
                     case 213:
 11860  
                         {
 11861  64
                         alt84=1;
 11862  
                         }
 11863  
                         break;
 11864  
 
 11865  
                     }
 11866  
 
 11867  
                     }
 11868  
                     break;
 11869  
 
 11870  
                 }
 11871  
 
 11872  288
                 switch (alt84) {
 11873  
                     case 1 :
 11874  
                         // com\\googlecode\\sparkleg\\Sparql.g:383:27: '.' triplesSameSubject
 11875  
                         {
 11876  64
                         char_literal265=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples3080);  
 11877  64
                         stream_DOT.add(char_literal265);
 11878  
 
 11879  
 
 11880  64
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples3082);
 11881  64
                         triplesSameSubject266=triplesSameSubject();
 11882  
 
 11883  132
                         state._fsp--;
 11884  
 
 11885  64
                         stream_triplesSameSubject.add(triplesSameSubject266.getTree());
 11886  
 
 11887  16
                         }
 11888  80
                         break;
 11889  
 
 11890  
                     default :
 11891  224
                         break loop84;
 11892  16
                 }
 11893  64
             } while (true);
 11894  16
 
 11895  
 
 11896  16
             // com\\googlecode\\sparkleg\\Sparql.g:383:52: ( '.' )?
 11897  208
             int alt85=2;
 11898  208
             switch ( input.LA(1) ) {
 11899  16
                 case DOT:
 11900  
                     {
 11901  110
                     alt85=1;
 11902  52
                     }
 11903  
                     break;
 11904  16
             }
 11905  
 
 11906  208
             switch (alt85) {
 11907  
                 case 1 :
 11908  52
                     // com\\googlecode\\sparkleg\\Sparql.g:383:52: '.'
 11909  52
                     {
 11910  110
                     char_literal267=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples3086);  
 11911  110
                     stream_DOT.add(char_literal267);
 11912  14
 
 11913  
 
 11914  
                     }
 11915  
                     break;
 11916  
 
 11917  52
             }
 11918  
 
 11919  
 
 11920  
             // AST REWRITE
 11921  14
             // elements: triplesSameSubject
 11922  14
             // token labels: 
 11923  
             // rule labels: retval
 11924  
             // token list labels: 
 11925  
             // rule list labels: 
 11926  
             // wildcard labels: 
 11927  208
             retval.tree = root_0;
 11928  208
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11929  
 
 11930  208
             root_0 = (Object)adaptor.nil();
 11931  
             // 383:57: -> ( triplesSameSubject )+
 11932  
             {
 11933  208
                 if ( !(stream_triplesSameSubject.hasNext()) ) {
 11934  0
                     throw new RewriteEarlyExitException();
 11935  
                 }
 11936  480
                 while ( stream_triplesSameSubject.hasNext() ) {
 11937  272
                     adaptor.addChild(root_0, stream_triplesSameSubject.nextTree());
 11938  52
 
 11939  52
                 }
 11940  208
                 stream_triplesSameSubject.reset();
 11941  52
 
 11942  
             }
 11943  
 
 11944  52
 
 11945  208
             retval.tree = root_0;
 11946  
 
 11947  120
             }
 11948  68
 
 11949  208
             retval.stop = input.LT(-1);
 11950  
 
 11951  52
 
 11952  208
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11953  208
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11954  
 
 11955  
         }
 11956  52
         catch (RecognitionException re) {
 11957  0
             reportError(re);
 11958  0
             recover(input,re);
 11959  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11960  52
 
 11961  
         }
 11962  
 
 11963  52
         finally {
 11964  52
                 // do for sure before leaving
 11965  208
         }
 11966  208
         return retval;
 11967  
     }
 11968  
     // $ANTLR end "constructTriples"
 11969  
 
 11970  
 
 11971  834
     public static class triplesSameSubject_return extends ParserRuleReturnScope {
 11972  
         Object tree;
 11973  834
         public Object getTree() { return tree; }
 11974  
     };
 11975  
 
 11976  52
 
 11977  52
     // $ANTLR start "triplesSameSubject"
 11978  
     // com\\googlecode\\sparkleg\\Sparql.g:386:1: triplesSameSubject : ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11979  
     public final SparqlParser.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 11980  834
         SparqlParser.triplesSameSubject_return retval = new SparqlParser.triplesSameSubject_return();
 11981  834
         retval.start = input.LT(1);
 11982  210
 
 11983  
 
 11984  210
         Object root_0 = null;
 11985  
 
 11986  834
         SparqlParser.varOrTerm_return varOrTerm268 =null;
 11987  
 
 11988  834
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty269 =null;
 11989  
 
 11990  834
         SparqlParser.triplesNode_return triplesNode270 =null;
 11991  210
 
 11992  1044
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty271 =null;
 11993  
 
 11994  
 
 11995  1044
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 11996  834
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 11997  1044
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 11998  
         try {
 11999  210
             // com\\googlecode\\sparkleg\\Sparql.g:387:5: ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12000  834
             int alt88=2;
 12001  1044
             switch ( input.LA(1) ) {
 12002  
             case BLANK_NODE_LABEL:
 12003  210
             case DECIMAL:
 12004  
             case DECIMAL_NEGATIVE:
 12005  
             case DECIMAL_POSITIVE:
 12006  210
             case DOUBLE:
 12007  210
             case DOUBLE_NEGATIVE:
 12008  210
             case DOUBLE_POSITIVE:
 12009  
             case FALSE:
 12010  
             case INTEGER:
 12011  210
             case INTEGER_NEGATIVE:
 12012  210
             case INTEGER_POSITIVE:
 12013  
             case IRI_REF:
 12014  
             case PNAME_LN:
 12015  
             case PNAME_NS:
 12016  
             case STRING_LITERAL1:
 12017  
             case STRING_LITERAL2:
 12018  
             case STRING_LITERAL_LONG1:
 12019  
             case STRING_LITERAL_LONG2:
 12020  
             case TRUE:
 12021  
             case VAR1:
 12022  
             case VAR2:
 12023  
                 {
 12024  786
                 alt88=1;
 12025  
                 }
 12026  786
                 break;
 12027  
             case 213:
 12028  
                 {
 12029  48
                 switch ( input.LA(2) ) {
 12030  
                 case 214:
 12031  
                     {
 12032  40
                     alt88=1;
 12033  
                     }
 12034  40
                     break;
 12035  198
                 case A:
 12036  
                 case INVERSE:
 12037  198
                 case IRI_REF:
 12038  
                 case NEGATION:
 12039  
                 case PNAME_LN:
 12040  12
                 case PNAME_NS:
 12041  
                 case VAR1:
 12042  
                 case VAR2:
 12043  10
                 case 209:
 12044  
                     {
 12045  18
                     alt88=2;
 12046  
                     }
 12047  8
                     break;
 12048  
                 default:
 12049  0
                     NoViableAltException nvae =
 12050  
                         new NoViableAltException("", 88, 2, input);
 12051  
 
 12052  0
                     throw nvae;
 12053  
 
 12054  
                 }
 12055  
 
 12056  2
                 }
 12057  48
                 break;
 12058  2
             case 209:
 12059  
                 {
 12060  0
                 switch ( input.LA(2) ) {
 12061  
                 case 210:
 12062  
                     {
 12063  0
                     alt88=1;
 12064  
                     }
 12065  0
                     break;
 12066  
                 case BLANK_NODE_LABEL:
 12067  
                 case DECIMAL:
 12068  12
                 case DECIMAL_NEGATIVE:
 12069  
                 case DECIMAL_POSITIVE:
 12070  
                 case DOUBLE:
 12071  
                 case DOUBLE_NEGATIVE:
 12072  
                 case DOUBLE_POSITIVE:
 12073  
                 case FALSE:
 12074  
                 case INTEGER:
 12075  
                 case INTEGER_NEGATIVE:
 12076  
                 case INTEGER_POSITIVE:
 12077  
                 case IRI_REF:
 12078  
                 case PNAME_LN:
 12079  
                 case PNAME_NS:
 12080  
                 case STRING_LITERAL1:
 12081  
                 case STRING_LITERAL2:
 12082  
                 case STRING_LITERAL_LONG1:
 12083  
                 case STRING_LITERAL_LONG2:
 12084  
                 case TRUE:
 12085  
                 case VAR1:
 12086  
                 case VAR2:
 12087  
                 case 209:
 12088  
                 case 213:
 12089  
                     {
 12090  0
                     alt88=2;
 12091  
                     }
 12092  0
                     break;
 12093  
                 default:
 12094  0
                     NoViableAltException nvae =
 12095  
                         new NoViableAltException("", 88, 3, input);
 12096  
 
 12097  0
                     throw nvae;
 12098  
 
 12099  
                 }
 12100  
 
 12101  
                 }
 12102  0
                 break;
 12103  
             default:
 12104  0
                 NoViableAltException nvae =
 12105  
                     new NoViableAltException("", 88, 0, input);
 12106  
 
 12107  0
                 throw nvae;
 12108  
 
 12109  
             }
 12110  
 
 12111  834
             switch (alt88) {
 12112  
                 case 1 :
 12113  
                     // com\\googlecode\\sparkleg\\Sparql.g:387:7: varOrTerm ( propertyListNotEmpty )?
 12114  
                     {
 12115  826
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject3109);
 12116  826
                     varOrTerm268=varOrTerm();
 12117  
 
 12118  826
                     state._fsp--;
 12119  
 
 12120  826
                     stream_varOrTerm.add(varOrTerm268.getTree());
 12121  
 
 12122  210
                     // com\\googlecode\\sparkleg\\Sparql.g:387:17: ( propertyListNotEmpty )?
 12123  826
                     int alt86=2;
 12124  826
                     switch ( input.LA(1) ) {
 12125  
                         case A:
 12126  208
                         case INVERSE:
 12127  208
                         case IRI_REF:
 12128  
                         case NEGATION:
 12129  208
                         case PNAME_LN:
 12130  
                         case PNAME_NS:
 12131  208
                         case VAR1:
 12132  
                         case VAR2:
 12133  208
                         case 209:
 12134  208
                             {
 12135  826
                             alt86=1;
 12136  208
                             }
 12137  
                             break;
 12138  208
                     }
 12139  
 
 12140  826
                     switch (alt86) {
 12141  
                         case 1 :
 12142  
                             // com\\googlecode\\sparkleg\\Sparql.g:387:17: propertyListNotEmpty
 12143  
                             {
 12144  826
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3111);
 12145  826
                             propertyListNotEmpty269=propertyListNotEmpty();
 12146  
 
 12147  1034
                             state._fsp--;
 12148  208
 
 12149  826
                             stream_propertyListNotEmpty.add(propertyListNotEmpty269.getTree());
 12150  208
 
 12151  
                             }
 12152  
                             break;
 12153  
 
 12154  
                     }
 12155  208
 
 12156  208
 
 12157  
                     // AST REWRITE
 12158  
                     // elements: propertyListNotEmpty, varOrTerm
 12159  
                     // token labels: 
 12160  
                     // rule labels: retval
 12161  
                     // token list labels: 
 12162  208
                     // rule list labels: 
 12163  208
                     // wildcard labels: 
 12164  826
                     retval.tree = root_0;
 12165  826
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12166  
 
 12167  1034
                     root_0 = (Object)adaptor.nil();
 12168  
                     // 387:39: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12169  208
                     {
 12170  
                         // com\\googlecode\\sparkleg\\Sparql.g:387:42: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12171  
                         {
 12172  1034
                         Object root_1 = (Object)adaptor.nil();
 12173  826
                         root_1 = (Object)adaptor.becomeRoot(
 12174  208
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12175  
                         , root_1);
 12176  
 
 12177  
                         // com\\googlecode\\sparkleg\\Sparql.g:387:65: ^( SUBJECT varOrTerm )
 12178  
                         {
 12179  826
                         Object root_2 = (Object)adaptor.nil();
 12180  1034
                         root_2 = (Object)adaptor.becomeRoot(
 12181  
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12182  
                         , root_2);
 12183  208
 
 12184  826
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12185  
 
 12186  826
                         adaptor.addChild(root_1, root_2);
 12187  2
                         }
 12188  2
 
 12189  
                         // com\\googlecode\\sparkleg\\Sparql.g:387:86: ( propertyListNotEmpty )?
 12190  828
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12191  826
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12192  2
 
 12193  
                         }
 12194  826
                         stream_propertyListNotEmpty.reset();
 12195  2
 
 12196  828
                         adaptor.addChild(root_0, root_1);
 12197  
                         }
 12198  
 
 12199  
                     }
 12200  
 
 12201  
 
 12202  826
                     retval.tree = root_0;
 12203  
 
 12204  
                     }
 12205  826
                     break;
 12206  
                 case 2 :
 12207  
                     // com\\googlecode\\sparkleg\\Sparql.g:388:7: triplesNode ( propertyListNotEmpty )?
 12208  
                     {
 12209  8
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject3135);
 12210  8
                     triplesNode270=triplesNode();
 12211  
 
 12212  10
                     state._fsp--;
 12213  
 
 12214  8
                     stream_triplesNode.add(triplesNode270.getTree());
 12215  
 
 12216  
                     // com\\googlecode\\sparkleg\\Sparql.g:388:19: ( propertyListNotEmpty )?
 12217  8
                     int alt87=2;
 12218  8
                     switch ( input.LA(1) ) {
 12219  
                         case A:
 12220  
                         case INVERSE:
 12221  
                         case IRI_REF:
 12222  
                         case NEGATION:
 12223  
                         case PNAME_LN:
 12224  
                         case PNAME_NS:
 12225  
                         case VAR1:
 12226  
                         case VAR2:
 12227  
                         case 209:
 12228  
                             {
 12229  0
                             alt87=1;
 12230  
                             }
 12231  
                             break;
 12232  
                     }
 12233  
 
 12234  8
                     switch (alt87) {
 12235  
                         case 1 :
 12236  2
                             // com\\googlecode\\sparkleg\\Sparql.g:388:19: propertyListNotEmpty
 12237  2
                             {
 12238  0
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3137);
 12239  2
                             propertyListNotEmpty271=propertyListNotEmpty();
 12240  
 
 12241  0
                             state._fsp--;
 12242  
 
 12243  0
                             stream_propertyListNotEmpty.add(propertyListNotEmpty271.getTree());
 12244  2
 
 12245  2
                             }
 12246  
                             break;
 12247  
 
 12248  
                     }
 12249  2
 
 12250  
 
 12251  
                     // AST REWRITE
 12252  2
                     // elements: triplesNode, propertyListNotEmpty
 12253  
                     // token labels: 
 12254  
                     // rule labels: retval
 12255  
                     // token list labels: 
 12256  2
                     // rule list labels: 
 12257  
                     // wildcard labels: 
 12258  10
                     retval.tree = root_0;
 12259  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12260  
 
 12261  8
                     root_0 = (Object)adaptor.nil();
 12262  
                     // 388:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12263  
                     {
 12264  2
                         // com\\googlecode\\sparkleg\\Sparql.g:388:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12265  
                         {
 12266  8
                         Object root_1 = (Object)adaptor.nil();
 12267  8
                         root_1 = (Object)adaptor.becomeRoot(
 12268  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12269  
                         , root_1);
 12270  210
 
 12271  8
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12272  
 
 12273  210
                         // com\\googlecode\\sparkleg\\Sparql.g:388:79: ( propertyListNotEmpty )?
 12274  218
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12275  0
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12276  
 
 12277  
                         }
 12278  8
                         stream_propertyListNotEmpty.reset();
 12279  
 
 12280  8
                         adaptor.addChild(root_0, root_1);
 12281  
                         }
 12282  
 
 12283  
                     }
 12284  
 
 12285  
 
 12286  218
                     retval.tree = root_0;
 12287  210
 
 12288  
                     }
 12289  
                     break;
 12290  
 
 12291  
             }
 12292  834
             retval.stop = input.LT(-1);
 12293  
 
 12294  246
 
 12295  834
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12296  834
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12297  
 
 12298  
         }
 12299  0
         catch (RecognitionException re) {
 12300  0
             reportError(re);
 12301  246
             recover(input,re);
 12302  246
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12303  
 
 12304  
         }
 12305  246
 
 12306  0
         finally {
 12307  246
                 // do for sure before leaving
 12308  1080
         }
 12309  834
         return retval;
 12310  246
     }
 12311  
     // $ANTLR end "triplesSameSubject"
 12312  
 
 12313  246
 
 12314  246
     public static class propertyListNotEmpty_return extends ParserRuleReturnScope {
 12315  246
         Object tree;
 12316  1008
         public Object getTree() { return tree; }
 12317  
     };
 12318  
 
 12319  
 
 12320  246
     // $ANTLR start "propertyListNotEmpty"
 12321  246
     // com\\googlecode\\sparkleg\\Sparql.g:391:1: propertyListNotEmpty : propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12322  
     public final SparqlParser.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 12323  1254
         SparqlParser.propertyListNotEmpty_return retval = new SparqlParser.propertyListNotEmpty_return();
 12324  1008
         retval.start = input.LT(1);
 12325  246
 
 12326  
 
 12327  1008
         Object root_0 = null;
 12328  
 
 12329  1008
         Token char_literal273=null;
 12330  1284
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails272 =null;
 12331  276
 
 12332  1008
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails274 =null;
 12333  
 
 12334  30
 
 12335  1008
         Object char_literal273_tree=null;
 12336  1008
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 12337  1008
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12338  
         try {
 12339  
             // com\\googlecode\\sparkleg\\Sparql.g:392:5: ( propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12340  276
             // com\\googlecode\\sparkleg\\Sparql.g:392:7: propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )*
 12341  
             {
 12342  1008
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3167);
 12343  1008
             propertyListNotEmptyDetails272=propertyListNotEmptyDetails();
 12344  30
 
 12345  1038
             state._fsp--;
 12346  
 
 12347  1008
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails272.getTree());
 12348  
 
 12349  30
             // com\\googlecode\\sparkleg\\Sparql.g:392:35: ( ';' ( propertyListNotEmptyDetails )? )*
 12350  30
             loop90:
 12351  
             do {
 12352  1137
                 int alt90=2;
 12353  1137
                 switch ( input.LA(1) ) {
 12354  
                 case 212:
 12355  
                     {
 12356  129
                     alt90=1;
 12357  
                     }
 12358  
                     break;
 12359  
 
 12360  
                 }
 12361  28
 
 12362  1137
                 switch (alt90) {
 12363  
                     case 1 :
 12364  
                         // com\\googlecode\\sparkleg\\Sparql.g:392:36: ';' ( propertyListNotEmptyDetails )?
 12365  
                         {
 12366  159
                         char_literal273=(Token)match(input,212,FOLLOW_212_in_propertyListNotEmpty3170);  
 12367  129
                         stream_212.add(char_literal273);
 12368  
 
 12369  
 
 12370  28
                         // com\\googlecode\\sparkleg\\Sparql.g:392:40: ( propertyListNotEmptyDetails )?
 12371  157
                         int alt89=2;
 12372  129
                         switch ( input.LA(1) ) {
 12373  28
                             case A:
 12374  
                             case INVERSE:
 12375  28
                             case IRI_REF:
 12376  
                             case NEGATION:
 12377  
                             case PNAME_LN:
 12378  
                             case PNAME_NS:
 12379  
                             case VAR1:
 12380  
                             case VAR2:
 12381  
                             case 209:
 12382  
                                 {
 12383  124
                                 alt89=1;
 12384  30
                                 }
 12385  
                                 break;
 12386  
                         }
 12387  246
 
 12388  129
                         switch (alt89) {
 12389  30
                             case 1 :
 12390  
                                 // com\\googlecode\\sparkleg\\Sparql.g:392:40: propertyListNotEmptyDetails
 12391  
                                 {
 12392  124
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3172);
 12393  124
                                 propertyListNotEmptyDetails274=propertyListNotEmptyDetails();
 12394  
 
 12395  124
                                 state._fsp--;
 12396  
 
 12397  124
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails274.getTree());
 12398  
 
 12399  246
                                 }
 12400  246
                                 break;
 12401  
 
 12402  246
                         }
 12403  
 
 12404  
 
 12405  246
                         }
 12406  129
                         break;
 12407  
 
 12408  520
                     default :
 12409  1282
                         break loop90;
 12410  
                 }
 12411  129
             } while (true);
 12412  246
 
 12413  
 
 12414  
             // AST REWRITE
 12415  
             // elements: propertyListNotEmptyDetails
 12416  
             // token labels: 
 12417  246
             // rule labels: retval
 12418  
             // token list labels: 
 12419  
             // rule list labels: 
 12420  
             // wildcard labels: 
 12421  1254
             retval.tree = root_0;
 12422  1008
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12423  
 
 12424  1254
             root_0 = (Object)adaptor.nil();
 12425  246
             // 392:71: -> ( propertyListNotEmptyDetails )+
 12426  
             {
 12427  1008
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12428  0
                     throw new RewriteEarlyExitException();
 12429  
                 }
 12430  2140
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12431  1132
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12432  
 
 12433  
                 }
 12434  1008
                 stream_propertyListNotEmptyDetails.reset();
 12435  
 
 12436  
             }
 12437  246
 
 12438  246
 
 12439  1008
             retval.tree = root_0;
 12440  
 
 12441  
             }
 12442  
 
 12443  3392
             retval.stop = input.LT(-1);
 12444  
 
 12445  3392
 
 12446  1008
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12447  1008
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12448  
 
 12449  
         }
 12450  0
         catch (RecognitionException re) {
 12451  0
             reportError(re);
 12452  3392
             recover(input,re);
 12453  3392
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12454  
 
 12455  
         }
 12456  3392
 
 12457  0
         finally {
 12458  3392
                 // do for sure before leaving
 12459  4400
         }
 12460  1008
         return retval;
 12461  3392
     }
 12462  
     // $ANTLR end "propertyListNotEmpty"
 12463  
 
 12464  3392
 
 12465  13442
     public static class objectList_return extends ParserRuleReturnScope {
 12466  3392
         Object tree;
 12467  13442
         public Object getTree() { return tree; }
 12468  
     };
 12469  
 
 12470  
 
 12471  3392
     // $ANTLR start "objectList"
 12472  3392
     // com\\googlecode\\sparkleg\\Sparql.g:395:1: objectList : graphNode ( ',' graphNode )* -> ( ^( OBJECT graphNode ) )+ ;
 12473  
     public final SparqlParser.objectList_return objectList() throws RecognitionException {
 12474  16834
         SparqlParser.objectList_return retval = new SparqlParser.objectList_return();
 12475  13442
         retval.start = input.LT(1);
 12476  3392
 
 12477  
 
 12478  13442
         Object root_0 = null;
 12479  
 
 12480  13442
         Token char_literal276=null;
 12481  16848
         SparqlParser.graphNode_return graphNode275 =null;
 12482  3406
 
 12483  13442
         SparqlParser.graphNode_return graphNode277 =null;
 12484  
 
 12485  14
 
 12486  13442
         Object char_literal276_tree=null;
 12487  13442
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 12488  13442
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 12489  
         try {
 12490  
             // com\\googlecode\\sparkleg\\Sparql.g:396:5: ( graphNode ( ',' graphNode )* -> ( ^( OBJECT graphNode ) )+ )
 12491  3406
             // com\\googlecode\\sparkleg\\Sparql.g:396:7: graphNode ( ',' graphNode )*
 12492  
             {
 12493  13442
             pushFollow(FOLLOW_graphNode_in_objectList3198);
 12494  13442
             graphNode275=graphNode();
 12495  14
 
 12496  13456
             state._fsp--;
 12497  
 
 12498  13442
             stream_graphNode.add(graphNode275.getTree());
 12499  14
 
 12500  14
             // com\\googlecode\\sparkleg\\Sparql.g:396:17: ( ',' graphNode )*
 12501  
             loop91:
 12502  14
             do {
 12503  13468
                 int alt91=2;
 12504  13482
                 switch ( input.LA(1) ) {
 12505  
                 case 211:
 12506  
                     {
 12507  40
                     alt91=1;
 12508  
                     }
 12509  
                     break;
 12510  3392
 
 12511  
                 }
 12512  14
 
 12513  13468
                 switch (alt91) {
 12514  
                     case 1 :
 12515  
                         // com\\googlecode\\sparkleg\\Sparql.g:396:18: ',' graphNode
 12516  
                         {
 12517  26
                         char_literal276=(Token)match(input,211,FOLLOW_211_in_objectList3201);  
 12518  26
                         stream_211.add(char_literal276);
 12519  
 
 12520  
 
 12521  26
                         pushFollow(FOLLOW_graphNode_in_objectList3203);
 12522  3418
                         graphNode277=graphNode();
 12523  3392
 
 12524  26
                         state._fsp--;
 12525  3392
 
 12526  26
                         stream_graphNode.add(graphNode277.getTree());
 12527  
 
 12528  3392
                         }
 12529  26
                         break;
 12530  
 
 12531  6798
                     default :
 12532  13442
                         break loop91;
 12533  
                 }
 12534  3432
             } while (true);
 12535  3406
 
 12536  
 
 12537  
             // AST REWRITE
 12538  
             // elements: graphNode
 12539  3406
             // token labels: 
 12540  
             // rule labels: retval
 12541  3406
             // token list labels: 
 12542  3406
             // rule list labels: 
 12543  
             // wildcard labels: 
 12544  13442
             retval.tree = root_0;
 12545  16834
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12546  
 
 12547  13442
             root_0 = (Object)adaptor.nil();
 12548  
             // 396:34: -> ( ^( OBJECT graphNode ) )+
 12549  
             {
 12550  16834
                 if ( !(stream_graphNode.hasNext()) ) {
 12551  0
                     throw new RewriteEarlyExitException();
 12552  
                 }
 12553  26910
                 while ( stream_graphNode.hasNext() ) {
 12554  3392
                     // com\\googlecode\\sparkleg\\Sparql.g:396:37: ^( OBJECT graphNode )
 12555  
                     {
 12556  13468
                     Object root_1 = (Object)adaptor.nil();
 12557  16860
                     root_1 = (Object)adaptor.becomeRoot(
 12558  3392
                     (Object)adaptor.create(OBJECT, "OBJECT")
 12559  
                     , root_1);
 12560  
 
 12561  13468
                     adaptor.addChild(root_1, stream_graphNode.nextTree());
 12562  
 
 12563  13468
                     adaptor.addChild(root_0, root_1);
 12564  13468
                     }
 12565  
 
 12566  
                 }
 12567  13442
                 stream_graphNode.reset();
 12568  
 
 12569  
             }
 12570  3392
 
 12571  3392
 
 12572  13442
             retval.tree = root_0;
 12573  
 
 12574  
             }
 12575  
 
 12576  13442
             retval.stop = input.LT(-1);
 12577  
 
 12578  
 
 12579  13442
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12580  13442
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12581  
 
 12582  
         }
 12583  0
         catch (RecognitionException re) {
 12584  0
             reportError(re);
 12585  0
             recover(input,re);
 12586  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12587  
 
 12588  
         }
 12589  
 
 12590  0
         finally {
 12591  
                 // do for sure before leaving
 12592  13442
         }
 12593  13442
         return retval;
 12594  
     }
 12595  
     // $ANTLR end "objectList"
 12596  
 
 12597  
 
 12598  0
     public static class verb_return extends ParserRuleReturnScope {
 12599  
         Object tree;
 12600  0
         public Object getTree() { return tree; }
 12601  
     };
 12602  
 
 12603  
 
 12604  
     // $ANTLR start "verb"
 12605  
     // com\\googlecode\\sparkleg\\Sparql.g:399:1: verb : ( varOrIRIref | A );
 12606  
     public final SparqlParser.verb_return verb() throws RecognitionException {
 12607  0
         SparqlParser.verb_return retval = new SparqlParser.verb_return();
 12608  0
         retval.start = input.LT(1);
 12609  
 
 12610  
 
 12611  0
         Object root_0 = null;
 12612  
 
 12613  0
         Token A279=null;
 12614  0
         SparqlParser.varOrIRIref_return varOrIRIref278 =null;
 12615  
 
 12616  
 
 12617  0
         Object A279_tree=null;
 12618  
 
 12619  
         try {
 12620  
             // com\\googlecode\\sparkleg\\Sparql.g:400:5: ( varOrIRIref | A )
 12621  0
             int alt92=2;
 12622  0
             switch ( input.LA(1) ) {
 12623  
             case IRI_REF:
 12624  
             case PNAME_LN:
 12625  
             case PNAME_NS:
 12626  
             case VAR1:
 12627  
             case VAR2:
 12628  
                 {
 12629  0
                 alt92=1;
 12630  
                 }
 12631  0
                 break;
 12632  
             case A:
 12633  
                 {
 12634  0
                 alt92=2;
 12635  
                 }
 12636  0
                 break;
 12637  
             default:
 12638  0
                 NoViableAltException nvae =
 12639  
                     new NoViableAltException("", 92, 0, input);
 12640  
 
 12641  0
                 throw nvae;
 12642  
 
 12643  
             }
 12644  
 
 12645  0
             switch (alt92) {
 12646  
                 case 1 :
 12647  
                     // com\\googlecode\\sparkleg\\Sparql.g:400:7: varOrIRIref
 12648  
                     {
 12649  0
                     root_0 = (Object)adaptor.nil();
 12650  
 
 12651  
 
 12652  0
                     pushFollow(FOLLOW_varOrIRIref_in_verb3231);
 12653  0
                     varOrIRIref278=varOrIRIref();
 12654  
 
 12655  0
                     state._fsp--;
 12656  
 
 12657  0
                     adaptor.addChild(root_0, varOrIRIref278.getTree());
 12658  
 
 12659  
                     }
 12660  0
                     break;
 12661  
                 case 2 :
 12662  
                     // com\\googlecode\\sparkleg\\Sparql.g:401:7: A
 12663  
                     {
 12664  0
                     root_0 = (Object)adaptor.nil();
 12665  
 
 12666  
 
 12667  0
                     A279=(Token)match(input,A,FOLLOW_A_in_verb3239); 
 12668  0
                     A279_tree = 
 12669  
                     (Object)adaptor.create(A279)
 12670  
                     ;
 12671  0
                     adaptor.addChild(root_0, A279_tree);
 12672  
 
 12673  
 
 12674  
                     }
 12675  
                     break;
 12676  
 
 12677  
             }
 12678  2946
             retval.stop = input.LT(-1);
 12679  
 
 12680  2946
 
 12681  0
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12682  0
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12683  
 
 12684  
         }
 12685  0
         catch (RecognitionException re) {
 12686  0
             reportError(re);
 12687  2946
             recover(input,re);
 12688  2946
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12689  
 
 12690  
         }
 12691  2946
 
 12692  0
         finally {
 12693  2946
                 // do for sure before leaving
 12694  0
         }
 12695  2946
         return retval;
 12696  
     }
 12697  2946
     // $ANTLR end "verb"
 12698  
 
 12699  2946
 
 12700  11634
     public static class triplesSameSubjectPath_return extends ParserRuleReturnScope {
 12701  
         Object tree;
 12702  11634
         public Object getTree() { return tree; }
 12703  2946
     };
 12704  2946
 
 12705  2946
 
 12706  
     // $ANTLR start "triplesSameSubjectPath"
 12707  
     // com\\googlecode\\sparkleg\\Sparql.g:404:1: triplesSameSubjectPath : ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 12708  2946
     public final SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 12709  14580
         SparqlParser.triplesSameSubjectPath_return retval = new SparqlParser.triplesSameSubjectPath_return();
 12710  11634
         retval.start = input.LT(1);
 12711  
 
 12712  
 
 12713  11634
         Object root_0 = null;
 12714  
 
 12715  11634
         SparqlParser.varOrTerm_return varOrTerm280 =null;
 12716  
 
 12717  11634
         SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath281 =null;
 12718  
 
 12719  11634
         SparqlParser.triplesNode_return triplesNode282 =null;
 12720  
 
 12721  11634
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty283 =null;
 12722  
 
 12723  
 
 12724  11634
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 12725  11634
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 12726  11634
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 12727  11634
         RewriteRuleSubtreeStream stream_propertyListNotEmptyPath=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyPath");
 12728  
         try {
 12729  
             // com\\googlecode\\sparkleg\\Sparql.g:405:5: ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12730  11634
             int alt94=2;
 12731  11634
             switch ( input.LA(1) ) {
 12732  2854
             case BLANK_NODE_LABEL:
 12733  
             case DECIMAL:
 12734  2854
             case DECIMAL_NEGATIVE:
 12735  
             case DECIMAL_POSITIVE:
 12736  
             case DOUBLE:
 12737  66
             case DOUBLE_NEGATIVE:
 12738  
             case DOUBLE_POSITIVE:
 12739  
             case FALSE:
 12740  54
             case INTEGER:
 12741  
             case INTEGER_NEGATIVE:
 12742  54
             case INTEGER_POSITIVE:
 12743  
             case IRI_REF:
 12744  
             case PNAME_LN:
 12745  
             case PNAME_NS:
 12746  
             case STRING_LITERAL1:
 12747  
             case STRING_LITERAL2:
 12748  
             case STRING_LITERAL_LONG1:
 12749  
             case STRING_LITERAL_LONG2:
 12750  
             case TRUE:
 12751  
             case VAR1:
 12752  
             case VAR2:
 12753  8
                 {
 12754  11278
                 alt94=1;
 12755  8
                 }
 12756  11278
                 break;
 12757  4
             case 213:
 12758  
                 {
 12759  264
                 switch ( input.LA(2) ) {
 12760  4
                 case 214:
 12761  
                     {
 12762  210
                     alt94=1;
 12763  
                     }
 12764  210
                     break;
 12765  62
                 case A:
 12766  
                 case INVERSE:
 12767  
                 case IRI_REF:
 12768  26
                 case NEGATION:
 12769  
                 case PNAME_LN:
 12770  
                 case PNAME_NS:
 12771  10
                 case VAR1:
 12772  
                 case VAR2:
 12773  10
                 case 209:
 12774  
                     {
 12775  50
                     alt94=2;
 12776  
                     }
 12777  50
                     break;
 12778  
                 default:
 12779  4
                     NoViableAltException nvae =
 12780  
                         new NoViableAltException("", 94, 2, input);
 12781  
 
 12782  4
                     throw nvae;
 12783  
 
 12784  
                 }
 12785  
 
 12786  
                 }
 12787  260
                 break;
 12788  
             case 209:
 12789  
                 {
 12790  92
                 switch ( input.LA(2) ) {
 12791  
                 case 210:
 12792  
                     {
 12793  28
                     alt94=1;
 12794  
                     }
 12795  28
                     break;
 12796  
                 case BLANK_NODE_LABEL:
 12797  
                 case DECIMAL:
 12798  16
                 case DECIMAL_NEGATIVE:
 12799  
                 case DECIMAL_POSITIVE:
 12800  16
                 case DOUBLE:
 12801  
                 case DOUBLE_NEGATIVE:
 12802  
                 case DOUBLE_POSITIVE:
 12803  
                 case FALSE:
 12804  
                 case INTEGER:
 12805  
                 case INTEGER_NEGATIVE:
 12806  
                 case INTEGER_POSITIVE:
 12807  
                 case IRI_REF:
 12808  
                 case PNAME_LN:
 12809  
                 case PNAME_NS:
 12810  26
                 case STRING_LITERAL1:
 12811  
                 case STRING_LITERAL2:
 12812  
                 case STRING_LITERAL_LONG1:
 12813  
                 case STRING_LITERAL_LONG2:
 12814  
                 case TRUE:
 12815  
                 case VAR1:
 12816  
                 case VAR2:
 12817  
                 case 209:
 12818  
                 case 213:
 12819  2942
                     {
 12820  64
                     alt94=2;
 12821  
                     }
 12822  64
                     break;
 12823  2918
                 default:
 12824  2918
                     NoViableAltException nvae =
 12825  
                         new NoViableAltException("", 94, 3, input);
 12826  2918
 
 12827  0
                     throw nvae;
 12828  2918
 
 12829  
                 }
 12830  2918
 
 12831  2918
                 }
 12832  92
                 break;
 12833  2918
             default:
 12834  0
                 NoViableAltException nvae =
 12835  2918
                     new NoViableAltException("", 94, 0, input);
 12836  
 
 12837  0
                 throw nvae;
 12838  
 
 12839  
             }
 12840  
 
 12841  11630
             switch (alt94) {
 12842  
                 case 1 :
 12843  
                     // com\\googlecode\\sparkleg\\Sparql.g:405:7: varOrTerm propertyListNotEmptyPath
 12844  2918
                     {
 12845  14434
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath3256);
 12846  11516
                     varOrTerm280=varOrTerm();
 12847  2918
 
 12848  11516
                     state._fsp--;
 12849  
 
 12850  11516
                     stream_varOrTerm.add(varOrTerm280.getTree());
 12851  
 
 12852  14434
                     pushFollow(FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3258);
 12853  14434
                     propertyListNotEmptyPath281=propertyListNotEmptyPath();
 12854  
 
 12855  11516
                     state._fsp--;
 12856  
 
 12857  11516
                     stream_propertyListNotEmptyPath.add(propertyListNotEmptyPath281.getTree());
 12858  
 
 12859  2918
                     // AST REWRITE
 12860  2918
                     // elements: propertyListNotEmptyPath, varOrTerm
 12861  
                     // token labels: 
 12862  
                     // rule labels: retval
 12863  
                     // token list labels: 
 12864  2918
                     // rule list labels: 
 12865  
                     // wildcard labels: 
 12866  14434
                     retval.tree = root_0;
 12867  11516
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12868  
 
 12869  14434
                     root_0 = (Object)adaptor.nil();
 12870  
                     // 405:42: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12871  2918
                     {
 12872  
                         // com\\googlecode\\sparkleg\\Sparql.g:405:45: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12873  
                         {
 12874  11516
                         Object root_1 = (Object)adaptor.nil();
 12875  11516
                         root_1 = (Object)adaptor.becomeRoot(
 12876  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12877  2918
                         , root_1);
 12878  
 
 12879  
                         // com\\googlecode\\sparkleg\\Sparql.g:405:68: ^( SUBJECT varOrTerm )
 12880  2918
                         {
 12881  11516
                         Object root_2 = (Object)adaptor.nil();
 12882  11516
                         root_2 = (Object)adaptor.becomeRoot(
 12883  
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12884  24
                         , root_2);
 12885  24
 
 12886  11516
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12887  24
 
 12888  11516
                         adaptor.addChild(root_1, root_2);
 12889  24
                         }
 12890  
 
 12891  11516
                         adaptor.addChild(root_1, stream_propertyListNotEmptyPath.nextTree());
 12892  24
 
 12893  11540
                         adaptor.addChild(root_0, root_1);
 12894  
                         }
 12895  
 
 12896  
                     }
 12897  
 
 12898  
 
 12899  11516
                     retval.tree = root_0;
 12900  
 
 12901  
                     }
 12902  11516
                     break;
 12903  
                 case 2 :
 12904  8
                     // com\\googlecode\\sparkleg\\Sparql.g:406:7: triplesNode ( propertyListNotEmpty )?
 12905  
                     {
 12906  114
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath3280);
 12907  114
                     triplesNode282=triplesNode();
 12908  
 
 12909  138
                     state._fsp--;
 12910  
 
 12911  114
                     stream_triplesNode.add(triplesNode282.getTree());
 12912  
 
 12913  8
                     // com\\googlecode\\sparkleg\\Sparql.g:406:19: ( propertyListNotEmpty )?
 12914  122
                     int alt93=2;
 12915  114
                     switch ( input.LA(1) ) {
 12916  8
                         case A:
 12917  
                         case INVERSE:
 12918  8
                         case IRI_REF:
 12919  
                         case NEGATION:
 12920  
                         case PNAME_LN:
 12921  
                         case PNAME_NS:
 12922  
                         case VAR1:
 12923  
                         case VAR2:
 12924  
                         case 209:
 12925  
                             {
 12926  38
                             alt93=1;
 12927  
                             }
 12928  
                             break;
 12929  
                     }
 12930  
 
 12931  114
                     switch (alt93) {
 12932  
                         case 1 :
 12933  24
                             // com\\googlecode\\sparkleg\\Sparql.g:406:19: propertyListNotEmpty
 12934  24
                             {
 12935  38
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3282);
 12936  62
                             propertyListNotEmpty283=propertyListNotEmpty();
 12937  
 
 12938  38
                             state._fsp--;
 12939  
 
 12940  38
                             stream_propertyListNotEmpty.add(propertyListNotEmpty283.getTree());
 12941  24
 
 12942  24
                             }
 12943  
                             break;
 12944  
 
 12945  
                     }
 12946  24
 
 12947  
 
 12948  
                     // AST REWRITE
 12949  24
                     // elements: propertyListNotEmpty, triplesNode
 12950  8
                     // token labels: 
 12951  
                     // rule labels: retval
 12952  
                     // token list labels: 
 12953  24
                     // rule list labels: 
 12954  
                     // wildcard labels: 
 12955  138
                     retval.tree = root_0;
 12956  114
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12957  
 
 12958  114
                     root_0 = (Object)adaptor.nil();
 12959  
                     // 406:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12960  
                     {
 12961  24
                         // com\\googlecode\\sparkleg\\Sparql.g:406:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12962  
                         {
 12963  114
                         Object root_1 = (Object)adaptor.nil();
 12964  114
                         root_1 = (Object)adaptor.becomeRoot(
 12965  
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12966  
                         , root_1);
 12967  2942
 
 12968  114
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12969  
 
 12970  2942
                         // com\\googlecode\\sparkleg\\Sparql.g:406:80: ( propertyListNotEmpty )?
 12971  3056
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12972  38
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12973  
 
 12974  4
                         }
 12975  118
                         stream_propertyListNotEmpty.reset();
 12976  4
 
 12977  118
                         adaptor.addChild(root_0, root_1);
 12978  
                         }
 12979  
 
 12980  
                     }
 12981  
 
 12982  
 
 12983  3060
                     retval.tree = root_0;
 12984  2946
 
 12985  
                     }
 12986  
                     break;
 12987  
 
 12988  
             }
 12989  11630
             retval.stop = input.LT(-1);
 12990  
 
 12991  2918
 
 12992  11630
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12993  11630
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12994  
 
 12995  
         }
 12996  4
         catch (RecognitionException re) {
 12997  4
             reportError(re);
 12998  2922
             recover(input,re);
 12999  2922
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13000  
 
 13001  
         }
 13002  2918
 
 13003  0
         finally {
 13004  2918
                 // do for sure before leaving
 13005  14552
         }
 13006  11634
         return retval;
 13007  2918
     }
 13008  
     // $ANTLR end "triplesSameSubjectPath"
 13009  
 
 13010  2918
 
 13011  2918
     public static class propertyListNotEmptyPath_return extends ParserRuleReturnScope {
 13012  2918
         Object tree;
 13013  11516
         public Object getTree() { return tree; }
 13014  
     };
 13015  
 
 13016  
 
 13017  2918
     // $ANTLR start "propertyListNotEmptyPath"
 13018  2918
     // com\\googlecode\\sparkleg\\Sparql.g:409:1: propertyListNotEmptyPath : propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 13019  
     public final SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath() throws RecognitionException {
 13020  14434
         SparqlParser.propertyListNotEmptyPath_return retval = new SparqlParser.propertyListNotEmptyPath_return();
 13021  11516
         retval.start = input.LT(1);
 13022  2918
 
 13023  
 
 13024  11516
         Object root_0 = null;
 13025  
 
 13026  11516
         Token char_literal285=null;
 13027  14646
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails284 =null;
 13028  3130
 
 13029  11516
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails286 =null;
 13030  
 
 13031  212
 
 13032  11516
         Object char_literal285_tree=null;
 13033  11516
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 13034  11516
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 13035  
         try {
 13036  
             // com\\googlecode\\sparkleg\\Sparql.g:410:5: ( propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 13037  3130
             // com\\googlecode\\sparkleg\\Sparql.g:410:7: propertyListNotEmptyDetails ( ';' ( propertyListNotEmptyDetails )? )*
 13038  
             {
 13039  11516
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3314);
 13040  11516
             propertyListNotEmptyDetails284=propertyListNotEmptyDetails();
 13041  212
 
 13042  11728
             state._fsp--;
 13043  
 
 13044  11516
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails284.getTree());
 13045  
 
 13046  212
             // com\\googlecode\\sparkleg\\Sparql.g:410:35: ( ';' ( propertyListNotEmptyDetails )? )*
 13047  212
             loop96:
 13048  
             do {
 13049  12334
                 int alt96=2;
 13050  12334
                 switch ( input.LA(1) ) {
 13051  
                 case 212:
 13052  
                     {
 13053  818
                     alt96=1;
 13054  
                     }
 13055  
                     break;
 13056  
 
 13057  
                 }
 13058  200
 
 13059  12334
                 switch (alt96) {
 13060  
                     case 1 :
 13061  
                         // com\\googlecode\\sparkleg\\Sparql.g:410:36: ';' ( propertyListNotEmptyDetails )?
 13062  
                         {
 13063  1030
                         char_literal285=(Token)match(input,212,FOLLOW_212_in_propertyListNotEmptyPath3317);  
 13064  818
                         stream_212.add(char_literal285);
 13065  
 
 13066  
 
 13067  200
                         // com\\googlecode\\sparkleg\\Sparql.g:410:40: ( propertyListNotEmptyDetails )?
 13068  1018
                         int alt95=2;
 13069  818
                         switch ( input.LA(1) ) {
 13070  200
                             case A:
 13071  
                             case INVERSE:
 13072  200
                             case IRI_REF:
 13073  
                             case NEGATION:
 13074  
                             case PNAME_LN:
 13075  
                             case PNAME_NS:
 13076  
                             case VAR1:
 13077  
                             case VAR2:
 13078  
                             case 209:
 13079  
                                 {
 13080  794
                                 alt95=1;
 13081  212
                                 }
 13082  
                                 break;
 13083  
                         }
 13084  2918
 
 13085  818
                         switch (alt95) {
 13086  212
                             case 1 :
 13087  
                                 // com\\googlecode\\sparkleg\\Sparql.g:410:40: propertyListNotEmptyDetails
 13088  
                                 {
 13089  794
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3319);
 13090  794
                                 propertyListNotEmptyDetails286=propertyListNotEmptyDetails();
 13091  
 
 13092  794
                                 state._fsp--;
 13093  
 
 13094  794
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails286.getTree());
 13095  
 
 13096  2918
                                 }
 13097  2918
                                 break;
 13098  
 
 13099  2918
                         }
 13100  
 
 13101  
 
 13102  2918
                         }
 13103  818
                         break;
 13104  
 
 13105  6036
                     default :
 13106  14634
                         break loop96;
 13107  
                 }
 13108  818
             } while (true);
 13109  2918
 
 13110  
 
 13111  
             // AST REWRITE
 13112  
             // elements: propertyListNotEmptyDetails
 13113  
             // token labels: 
 13114  2918
             // rule labels: retval
 13115  
             // token list labels: 
 13116  
             // rule list labels: 
 13117  
             // wildcard labels: 
 13118  14434
             retval.tree = root_0;
 13119  11516
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13120  
 
 13121  14434
             root_0 = (Object)adaptor.nil();
 13122  2918
             // 410:71: -> ( propertyListNotEmptyDetails )+
 13123  
             {
 13124  11516
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 13125  0
                     throw new RewriteEarlyExitException();
 13126  
                 }
 13127  23826
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 13128  12310
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 13129  
 
 13130  
                 }
 13131  11516
                 stream_propertyListNotEmptyDetails.reset();
 13132  
 
 13133  
             }
 13134  2918
 
 13135  2918
 
 13136  11516
             retval.tree = root_0;
 13137  
 
 13138  
             }
 13139  
 
 13140  11516
             retval.stop = input.LT(-1);
 13141  
 
 13142  3392
 
 13143  11516
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13144  11516
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13145  
 
 13146  
         }
 13147  0
         catch (RecognitionException re) {
 13148  0
             reportError(re);
 13149  3392
             recover(input,re);
 13150  3392
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13151  
 
 13152  
         }
 13153  3392
 
 13154  0
         finally {
 13155  3392
                 // do for sure before leaving
 13156  11516
         }
 13157  14908
         return retval;
 13158  
     }
 13159  
     // $ANTLR end "propertyListNotEmptyPath"
 13160  3392
 
 13161  3392
 
 13162  13442
     public static class propertyListNotEmptyDetails_return extends ParserRuleReturnScope {
 13163  
         Object tree;
 13164  13442
         public Object getTree() { return tree; }
 13165  
     };
 13166  3392
 
 13167  3392
 
 13168  
     // $ANTLR start "propertyListNotEmptyDetails"
 13169  3392
     // com\\googlecode\\sparkleg\\Sparql.g:413:1: propertyListNotEmptyDetails : verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) ;
 13170  
     public final SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 13171  16834
         SparqlParser.propertyListNotEmptyDetails_return retval = new SparqlParser.propertyListNotEmptyDetails_return();
 13172  13442
         retval.start = input.LT(1);
 13173  3392
 
 13174  3392
 
 13175  13442
         Object root_0 = null;
 13176  3392
 
 13177  13442
         SparqlParser.verbSimpleOrPath_return verbSimpleOrPath287 =null;
 13178  3392
 
 13179  13442
         SparqlParser.objectList_return objectList288 =null;
 13180  
 
 13181  
 
 13182  13442
         RewriteRuleSubtreeStream stream_verbSimpleOrPath=new RewriteRuleSubtreeStream(adaptor,"rule verbSimpleOrPath");
 13183  13442
         RewriteRuleSubtreeStream stream_objectList=new RewriteRuleSubtreeStream(adaptor,"rule objectList");
 13184  
         try {
 13185  
             // com\\googlecode\\sparkleg\\Sparql.g:414:5: ( verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) )
 13186  
             // com\\googlecode\\sparkleg\\Sparql.g:414:7: verbSimpleOrPath objectList
 13187  3392
             {
 13188  16834
             pushFollow(FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3346);
 13189  13442
             verbSimpleOrPath287=verbSimpleOrPath();
 13190  3392
 
 13191  13442
             state._fsp--;
 13192  
 
 13193  13442
             stream_verbSimpleOrPath.add(verbSimpleOrPath287.getTree());
 13194  
 
 13195  16834
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails3348);
 13196  16834
             objectList288=objectList();
 13197  
 
 13198  13442
             state._fsp--;
 13199  
 
 13200  16834
             stream_objectList.add(objectList288.getTree());
 13201  
 
 13202  3392
             // AST REWRITE
 13203  
             // elements: verbSimpleOrPath, objectList
 13204  3392
             // token labels: 
 13205  
             // rule labels: retval
 13206  
             // token list labels: 
 13207  
             // rule list labels: 
 13208  
             // wildcard labels: 
 13209  13442
             retval.tree = root_0;
 13210  16834
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13211  
 
 13212  13442
             root_0 = (Object)adaptor.nil();
 13213  
             // 414:35: -> ^( PREDICATE verbSimpleOrPath objectList )
 13214  3392
             {
 13215  
                 // com\\googlecode\\sparkleg\\Sparql.g:414:38: ^( PREDICATE verbSimpleOrPath objectList )
 13216  
                 {
 13217  16834
                 Object root_1 = (Object)adaptor.nil();
 13218  16834
                 root_1 = (Object)adaptor.becomeRoot(
 13219  
                 (Object)adaptor.create(PREDICATE, "PREDICATE")
 13220  
                 , root_1);
 13221  
 
 13222  13442
                 adaptor.addChild(root_1, stream_verbSimpleOrPath.nextTree());
 13223  
 
 13224  13442
                 adaptor.addChild(root_1, stream_objectList.nextTree());
 13225  
 
 13226  13442
                 adaptor.addChild(root_0, root_1);
 13227  
                 }
 13228  
 
 13229  
             }
 13230  3392
 
 13231  3392
 
 13232  13442
             retval.tree = root_0;
 13233  
 
 13234  
             }
 13235  
 
 13236  3392
             retval.stop = input.LT(-1);
 13237  
 
 13238  3392
 
 13239  13442
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13240  13442
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13241  
 
 13242  
         }
 13243  0
         catch (RecognitionException re) {
 13244  0
             reportError(re);
 13245  3392
             recover(input,re);
 13246  3392
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13247  
 
 13248  
         }
 13249  3392
 
 13250  0
         finally {
 13251  3392
                 // do for sure before leaving
 13252  13442
         }
 13253  16834
         return retval;
 13254  
     }
 13255  
     // $ANTLR end "propertyListNotEmptyDetails"
 13256  
 
 13257  
 
 13258  13442
     public static class verbSimpleOrPath_return extends ParserRuleReturnScope {
 13259  3392
         Object tree;
 13260  13442
         public Object getTree() { return tree; }
 13261  
     };
 13262  
 
 13263  
 
 13264  
     // $ANTLR start "verbSimpleOrPath"
 13265  
     // com\\googlecode\\sparkleg\\Sparql.g:417:1: verbSimpleOrPath : ( verbPath | verbSimple );
 13266  
     public final SparqlParser.verbSimpleOrPath_return verbSimpleOrPath() throws RecognitionException {
 13267  13442
         SparqlParser.verbSimpleOrPath_return retval = new SparqlParser.verbSimpleOrPath_return();
 13268  13442
         retval.start = input.LT(1);
 13269  2672
 
 13270  
 
 13271  16114
         Object root_0 = null;
 13272  
 
 13273  13442
         SparqlParser.verbPath_return verbPath289 =null;
 13274  
 
 13275  14142
         SparqlParser.verbSimple_return verbSimple290 =null;
 13276  
 
 13277  700
 
 13278  
 
 13279  20
         try {
 13280  
             // com\\googlecode\\sparkleg\\Sparql.g:418:5: ( verbPath | verbSimple )
 13281  13442
             int alt97=2;
 13282  13462
             switch ( input.LA(1) ) {
 13283  
             case A:
 13284  
             case INVERSE:
 13285  
             case IRI_REF:
 13286  3372
             case NEGATION:
 13287  
             case PNAME_LN:
 13288  
             case PNAME_NS:
 13289  
             case 209:
 13290  2672
                 {
 13291  10670
                 alt97=1;
 13292  
                 }
 13293  13342
                 break;
 13294  2672
             case VAR1:
 13295  
             case VAR2:
 13296  2672
                 {
 13297  2752
                 alt97=2;
 13298  2672
                 }
 13299  2752
                 break;
 13300  
             default:
 13301  2692
                 NoViableAltException nvae =
 13302  
                     new NoViableAltException("", 97, 0, input);
 13303  
 
 13304  20
                 throw nvae;
 13305  700
 
 13306  
             }
 13307  
 
 13308  14122
             switch (alt97) {
 13309  700
                 case 1 :
 13310  
                     // com\\googlecode\\sparkleg\\Sparql.g:418:7: verbPath
 13311  700
                     {
 13312  10670
                     root_0 = (Object)adaptor.nil();
 13313  700
 
 13314  
 
 13315  10670
                     pushFollow(FOLLOW_verbPath_in_verbSimpleOrPath3378);
 13316  10670
                     verbPath289=verbPath();
 13317  
 
 13318  10670
                     state._fsp--;
 13319  3372
 
 13320  10670
                     adaptor.addChild(root_0, verbPath289.getTree());
 13321  
 
 13322  3372
                     }
 13323  14042
                     break;
 13324  
                 case 2 :
 13325  
                     // com\\googlecode\\sparkleg\\Sparql.g:419:7: verbSimple
 13326  20
                     {
 13327  2772
                     root_0 = (Object)adaptor.nil();
 13328  20
 
 13329  20
 
 13330  2752
                     pushFollow(FOLLOW_verbSimple_in_verbSimpleOrPath3386);
 13331  2752
                     verbSimple290=verbSimple();
 13332  
 
 13333  2752
                     state._fsp--;
 13334  
 
 13335  6144
                     adaptor.addChild(root_0, verbSimple290.getTree());
 13336  3392
 
 13337  
                     }
 13338  
                     break;
 13339  
 
 13340  
             }
 13341  2672
             retval.stop = input.LT(-1);
 13342  
 
 13343  2672
 
 13344  13422
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13345  13422
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13346  
 
 13347  
         }
 13348  20
         catch (RecognitionException re) {
 13349  20
             reportError(re);
 13350  2692
             recover(input,re);
 13351  2692
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13352  
 
 13353  
         }
 13354  2672
 
 13355  0
         finally {
 13356  2672
                 // do for sure before leaving
 13357  13442
         }
 13358  13442
         return retval;
 13359  
     }
 13360  
     // $ANTLR end "verbSimpleOrPath"
 13361  
 
 13362  
 
 13363  10670
     public static class verbPath_return extends ParserRuleReturnScope {
 13364  2672
         Object tree;
 13365  10670
         public Object getTree() { return tree; }
 13366  
     };
 13367  2672
 
 13368  2672
 
 13369  
     // $ANTLR start "verbPath"
 13370  2672
     // com\\googlecode\\sparkleg\\Sparql.g:422:1: verbPath : path ;
 13371  
     public final SparqlParser.verbPath_return verbPath() throws RecognitionException {
 13372  13342
         SparqlParser.verbPath_return retval = new SparqlParser.verbPath_return();
 13373  10670
         retval.start = input.LT(1);
 13374  
 
 13375  
 
 13376  13342
         Object root_0 = null;
 13377  
 
 13378  10670
         SparqlParser.path_return path291 =null;
 13379  2672
 
 13380  2672
 
 13381  
 
 13382  
         try {
 13383  
             // com\\googlecode\\sparkleg\\Sparql.g:423:5: ( path )
 13384  
             // com\\googlecode\\sparkleg\\Sparql.g:423:7: path
 13385  
             {
 13386  10670
             root_0 = (Object)adaptor.nil();
 13387  
 
 13388  
 
 13389  10670
             pushFollow(FOLLOW_path_in_verbPath3405);
 13390  10670
             path291=path();
 13391  
 
 13392  13342
             state._fsp--;
 13393  2672
 
 13394  10670
             adaptor.addChild(root_0, path291.getTree());
 13395  
 
 13396  
             }
 13397  
 
 13398  10670
             retval.stop = input.LT(-1);
 13399  
 
 13400  700
 
 13401  10670
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13402  10670
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13403  
 
 13404  
         }
 13405  0
         catch (RecognitionException re) {
 13406  0
             reportError(re);
 13407  700
             recover(input,re);
 13408  700
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13409  
 
 13410  
         }
 13411  700
 
 13412  0
         finally {
 13413  700
                 // do for sure before leaving
 13414  10670
         }
 13415  10670
         return retval;
 13416  
     }
 13417  
     // $ANTLR end "verbPath"
 13418  
 
 13419  
 
 13420  2752
     public static class verbSimple_return extends ParserRuleReturnScope {
 13421  700
         Object tree;
 13422  2752
         public Object getTree() { return tree; }
 13423  
     };
 13424  700
 
 13425  700
 
 13426  
     // $ANTLR start "verbSimple"
 13427  700
     // com\\googlecode\\sparkleg\\Sparql.g:426:1: verbSimple : var ;
 13428  
     public final SparqlParser.verbSimple_return verbSimple() throws RecognitionException {
 13429  3452
         SparqlParser.verbSimple_return retval = new SparqlParser.verbSimple_return();
 13430  2752
         retval.start = input.LT(1);
 13431  
 
 13432  
 
 13433  3452
         Object root_0 = null;
 13434  
 
 13435  2752
         SparqlParser.var_return var292 =null;
 13436  700
 
 13437  700
 
 13438  
 
 13439  
         try {
 13440  
             // com\\googlecode\\sparkleg\\Sparql.g:427:5: ( var )
 13441  
             // com\\googlecode\\sparkleg\\Sparql.g:427:7: var
 13442  
             {
 13443  2752
             root_0 = (Object)adaptor.nil();
 13444  
 
 13445  
 
 13446  2752
             pushFollow(FOLLOW_var_in_verbSimple3426);
 13447  2752
             var292=var();
 13448  
 
 13449  3452
             state._fsp--;
 13450  700
 
 13451  2752
             adaptor.addChild(root_0, var292.getTree());
 13452  
 
 13453  
             }
 13454  
 
 13455  2752
             retval.stop = input.LT(-1);
 13456  
 
 13457  2692
 
 13458  2752
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13459  2752
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13460  
 
 13461  
         }
 13462  0
         catch (RecognitionException re) {
 13463  0
             reportError(re);
 13464  2692
             recover(input,re);
 13465  2692
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13466  
 
 13467  
         }
 13468  2692
 
 13469  0
         finally {
 13470  2692
                 // do for sure before leaving
 13471  5444
         }
 13472  2752
         return retval;
 13473  2692
     }
 13474  
     // $ANTLR end "verbSimple"
 13475  
 
 13476  2692
 
 13477  2692
     public static class path_return extends ParserRuleReturnScope {
 13478  2692
         Object tree;
 13479  10750
         public Object getTree() { return tree; }
 13480  
     };
 13481  
 
 13482  
 
 13483  2692
     // $ANTLR start "path"
 13484  2692
     // com\\googlecode\\sparkleg\\Sparql.g:430:1: path : pathSequence ( '|' pathSequence )* -> ^( PATH ( pathSequence )+ ) ;
 13485  
     public final SparqlParser.path_return path() throws RecognitionException {
 13486  13442
         SparqlParser.path_return retval = new SparqlParser.path_return();
 13487  10750
         retval.start = input.LT(1);
 13488  2692
 
 13489  
 
 13490  10750
         Object root_0 = null;
 13491  
 
 13492  10750
         Token char_literal294=null;
 13493  13462
         SparqlParser.pathSequence_return pathSequence293 =null;
 13494  2712
 
 13495  10750
         SparqlParser.pathSequence_return pathSequence295 =null;
 13496  
 
 13497  20
 
 13498  10750
         Object char_literal294_tree=null;
 13499  10750
         RewriteRuleTokenStream stream_217=new RewriteRuleTokenStream(adaptor,"token 217");
 13500  10750
         RewriteRuleSubtreeStream stream_pathSequence=new RewriteRuleSubtreeStream(adaptor,"rule pathSequence");
 13501  
         try {
 13502  
             // com\\googlecode\\sparkleg\\Sparql.g:431:5: ( pathSequence ( '|' pathSequence )* -> ^( PATH ( pathSequence )+ ) )
 13503  2712
             // com\\googlecode\\sparkleg\\Sparql.g:431:7: pathSequence ( '|' pathSequence )*
 13504  
             {
 13505  10750
             pushFollow(FOLLOW_pathSequence_in_path3448);
 13506  10750
             pathSequence293=pathSequence();
 13507  20
 
 13508  10770
             state._fsp--;
 13509  
 
 13510  10750
             stream_pathSequence.add(pathSequence293.getTree());
 13511  20
 
 13512  20
             // com\\googlecode\\sparkleg\\Sparql.g:431:20: ( '|' pathSequence )*
 13513  
             loop98:
 13514  20
             do {
 13515  10830
                 int alt98=2;
 13516  10850
                 switch ( input.LA(1) ) {
 13517  
                 case 217:
 13518  
                     {
 13519  100
                     alt98=1;
 13520  
                     }
 13521  
                     break;
 13522  2692
 
 13523  
                 }
 13524  20
 
 13525  10830
                 switch (alt98) {
 13526  
                     case 1 :
 13527  
                         // com\\googlecode\\sparkleg\\Sparql.g:431:21: '|' pathSequence
 13528  
                         {
 13529  80
                         char_literal294=(Token)match(input,217,FOLLOW_217_in_path3451);  
 13530  80
                         stream_217.add(char_literal294);
 13531  
 
 13532  
 
 13533  80
                         pushFollow(FOLLOW_pathSequence_in_path3453);
 13534  2772
                         pathSequence295=pathSequence();
 13535  2692
 
 13536  80
                         state._fsp--;
 13537  2692
 
 13538  80
                         stream_pathSequence.add(pathSequence295.getTree());
 13539  
 
 13540  
                         }
 13541  80
                         break;
 13542  2692
 
 13543  2692
                     default :
 13544  10750
                         break loop98;
 13545  
                 }
 13546  80
             } while (true);
 13547  2692
 
 13548  
 
 13549  
             // AST REWRITE
 13550  5404
             // elements: pathSequence
 13551  2712
             // token labels: 
 13552  
             // rule labels: retval
 13553  
             // token list labels: 
 13554  2692
             // rule list labels: 
 13555  
             // wildcard labels: 
 13556  13442
             retval.tree = root_0;
 13557  10750
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13558  
 
 13559  10750
             root_0 = (Object)adaptor.nil();
 13560  
             // 431:40: -> ^( PATH ( pathSequence )+ )
 13561  
             {
 13562  2692
                 // com\\googlecode\\sparkleg\\Sparql.g:431:43: ^( PATH ( pathSequence )+ )
 13563  
                 {
 13564  10750
                 Object root_1 = (Object)adaptor.nil();
 13565  10750
                 root_1 = (Object)adaptor.becomeRoot(
 13566  2692
                 (Object)adaptor.create(PATH, "PATH")
 13567  
                 , root_1);
 13568  
 
 13569  13442
                 if ( !(stream_pathSequence.hasNext()) ) {
 13570  2692
                     throw new RewriteEarlyExitException();
 13571  
                 }
 13572  21580
                 while ( stream_pathSequence.hasNext() ) {
 13573  10830
                     adaptor.addChild(root_1, stream_pathSequence.nextTree());
 13574  
 
 13575  
                 }
 13576  10750
                 stream_pathSequence.reset();
 13577  
 
 13578  10750
                 adaptor.addChild(root_0, root_1);
 13579  
                 }
 13580  
 
 13581  
             }
 13582  2692
 
 13583  2692
 
 13584  10750
             retval.tree = root_0;
 13585  
 
 13586  
             }
 13587  
 
 13588  10750
             retval.stop = input.LT(-1);
 13589  
 
 13590  2712
 
 13591  10750
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13592  10750
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13593  
 
 13594  
         }
 13595  0
         catch (RecognitionException re) {
 13596  0
             reportError(re);
 13597  2712
             recover(input,re);
 13598  2712
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13599  
 
 13600  
         }
 13601  2712
 
 13602  0
         finally {
 13603  2712
                 // do for sure before leaving
 13604  13462
         }
 13605  10750
         return retval;
 13606  2712
     }
 13607  
     // $ANTLR end "path"
 13608  
 
 13609  2712
 
 13610  2712
     public static class pathSequence_return extends ParserRuleReturnScope {
 13611  2712
         Object tree;
 13612  10830
         public Object getTree() { return tree; }
 13613  
     };
 13614  
 
 13615  
 
 13616  2712
     // $ANTLR start "pathSequence"
 13617  2712
     // com\\googlecode\\sparkleg\\Sparql.g:434:1: pathSequence : pathEltOrInverse ( '/' pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 13618  
     public final SparqlParser.pathSequence_return pathSequence() throws RecognitionException {
 13619  13542
         SparqlParser.pathSequence_return retval = new SparqlParser.pathSequence_return();
 13620  10830
         retval.start = input.LT(1);
 13621  2712
 
 13622  
 
 13623  10830
         Object root_0 = null;
 13624  
 
 13625  10830
         Token char_literal297=null;
 13626  13606
         SparqlParser.pathEltOrInverse_return pathEltOrInverse296 =null;
 13627  2776
 
 13628  10830
         SparqlParser.pathEltOrInverse_return pathEltOrInverse298 =null;
 13629  
 
 13630  64
 
 13631  10830
         Object char_literal297_tree=null;
 13632  10830
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 13633  10830
         RewriteRuleSubtreeStream stream_pathEltOrInverse=new RewriteRuleSubtreeStream(adaptor,"rule pathEltOrInverse");
 13634  
         try {
 13635  
             // com\\googlecode\\sparkleg\\Sparql.g:435:5: ( pathEltOrInverse ( '/' pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 13636  2776
             // com\\googlecode\\sparkleg\\Sparql.g:435:7: pathEltOrInverse ( '/' pathEltOrInverse )*
 13637  
             {
 13638  10830
             pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3482);
 13639  10830
             pathEltOrInverse296=pathEltOrInverse();
 13640  64
 
 13641  10894
             state._fsp--;
 13642  
 
 13643  10830
             stream_pathEltOrInverse.add(pathEltOrInverse296.getTree());
 13644  64
 
 13645  64
             // com\\googlecode\\sparkleg\\Sparql.g:435:24: ( '/' pathEltOrInverse )*
 13646  
             loop99:
 13647  64
             do {
 13648  11086
                 int alt99=2;
 13649  11150
                 switch ( input.LA(1) ) {
 13650  
                 case DIVIDE:
 13651  
                     {
 13652  320
                     alt99=1;
 13653  
                     }
 13654  
                     break;
 13655  2712
 
 13656  
                 }
 13657  64
 
 13658  11086
                 switch (alt99) {
 13659  
                     case 1 :
 13660  
                         // com\\googlecode\\sparkleg\\Sparql.g:435:25: '/' pathEltOrInverse
 13661  
                         {
 13662  256
                         char_literal297=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_pathSequence3485);  
 13663  256
                         stream_DIVIDE.add(char_literal297);
 13664  
 
 13665  
 
 13666  256
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3487);
 13667  2968
                         pathEltOrInverse298=pathEltOrInverse();
 13668  2712
 
 13669  256
                         state._fsp--;
 13670  2712
 
 13671  256
                         stream_pathEltOrInverse.add(pathEltOrInverse298.getTree());
 13672  
 
 13673  
                         }
 13674  256
                         break;
 13675  2712
 
 13676  2712
                     default :
 13677  10830
                         break loop99;
 13678  
                 }
 13679  256
             } while (true);
 13680  2712
 
 13681  
 
 13682  
             // AST REWRITE
 13683  5488
             // elements: pathEltOrInverse
 13684  2776
             // token labels: 
 13685  
             // rule labels: retval
 13686  
             // token list labels: 
 13687  2712
             // rule list labels: 
 13688  
             // wildcard labels: 
 13689  13542
             retval.tree = root_0;
 13690  10830
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13691  
 
 13692  10830
             root_0 = (Object)adaptor.nil();
 13693  
             // 435:48: -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13694  
             {
 13695  2712
                 // com\\googlecode\\sparkleg\\Sparql.g:435:51: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13696  
                 {
 13697  10830
                 Object root_1 = (Object)adaptor.nil();
 13698  10830
                 root_1 = (Object)adaptor.becomeRoot(
 13699  2712
                 (Object)adaptor.create(PATH_SEQUENCE, "PATH_SEQUENCE")
 13700  
                 , root_1);
 13701  
 
 13702  13542
                 if ( !(stream_pathEltOrInverse.hasNext()) ) {
 13703  2712
                     throw new RewriteEarlyExitException();
 13704  
                 }
 13705  21916
                 while ( stream_pathEltOrInverse.hasNext() ) {
 13706  11086
                     adaptor.addChild(root_1, stream_pathEltOrInverse.nextTree());
 13707  
 
 13708  
                 }
 13709  10830
                 stream_pathEltOrInverse.reset();
 13710  
 
 13711  10830
                 adaptor.addChild(root_0, root_1);
 13712  
                 }
 13713  
 
 13714  
             }
 13715  2712
 
 13716  2712
 
 13717  10830
             retval.tree = root_0;
 13718  
 
 13719  
             }
 13720  
 
 13721  2776
             retval.stop = input.LT(-1);
 13722  
 
 13723  2776
 
 13724  10830
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13725  10830
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13726  
 
 13727  
         }
 13728  0
         catch (RecognitionException re) {
 13729  0
             reportError(re);
 13730  2776
             recover(input,re);
 13731  2776
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13732  
 
 13733  
         }
 13734  2776
 
 13735  0
         finally {
 13736  2776
                 // do for sure before leaving
 13737  13606
         }
 13738  10830
         return retval;
 13739  
     }
 13740  2776
     // $ANTLR end "pathSequence"
 13741  
 
 13742  
 
 13743  11086
     public static class pathEltOrInverse_return extends ParserRuleReturnScope {
 13744  
         Object tree;
 13745  11086
         public Object getTree() { return tree; }
 13746  2776
     };
 13747  
 
 13748  
 
 13749  
     // $ANTLR start "pathEltOrInverse"
 13750  2776
     // com\\googlecode\\sparkleg\\Sparql.g:438:1: pathEltOrInverse : (i= '^' )? pathElt -> ^( PATH_ELT_OR_INVERSE ( $i)? pathElt ) ;
 13751  2776
     public final SparqlParser.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 13752  11086
         SparqlParser.pathEltOrInverse_return retval = new SparqlParser.pathEltOrInverse_return();
 13753  11086
         retval.start = input.LT(1);
 13754  12
 
 13755  
 
 13756  11086
         Object root_0 = null;
 13757  
 
 13758  11086
         Token i=null;
 13759  13862
         SparqlParser.pathElt_return pathElt299 =null;
 13760  
 
 13761  
 
 13762  11086
         Object i_tree=null;
 13763  11098
         RewriteRuleTokenStream stream_INVERSE=new RewriteRuleTokenStream(adaptor,"token INVERSE");
 13764  11098
         RewriteRuleSubtreeStream stream_pathElt=new RewriteRuleSubtreeStream(adaptor,"rule pathElt");
 13765  
         try {
 13766  
             // com\\googlecode\\sparkleg\\Sparql.g:439:5: ( (i= '^' )? pathElt -> ^( PATH_ELT_OR_INVERSE ( $i)? pathElt ) )
 13767  12
             // com\\googlecode\\sparkleg\\Sparql.g:439:7: (i= '^' )? pathElt
 13768  
             {
 13769  
             // com\\googlecode\\sparkleg\\Sparql.g:439:7: (i= '^' )?
 13770  11086
             int alt100=2;
 13771  11086
             switch ( input.LA(1) ) {
 13772  
                 case INVERSE:
 13773  
                     {
 13774  48
                     alt100=1;
 13775  
                     }
 13776  2776
                     break;
 13777  2776
             }
 13778  
 
 13779  13862
             switch (alt100) {
 13780  
                 case 1 :
 13781  2776
                     // com\\googlecode\\sparkleg\\Sparql.g:439:8: i= '^'
 13782  
                     {
 13783  48
                     i=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse3518);  
 13784  48
                     stream_INVERSE.add(i);
 13785  2776
 
 13786  
 
 13787  
                     }
 13788  2776
                     break;
 13789  2776
 
 13790  
             }
 13791  
 
 13792  
 
 13793  11086
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse3522);
 13794  11086
             pathElt299=pathElt();
 13795  
 
 13796  11086
             state._fsp--;
 13797  
 
 13798  11086
             stream_pathElt.add(pathElt299.getTree());
 13799  
 
 13800  
             // AST REWRITE
 13801  2776
             // elements: i, pathElt
 13802  2776
             // token labels: i
 13803  
             // rule labels: retval
 13804  
             // token list labels: 
 13805  
             // rule list labels: 
 13806  
             // wildcard labels: 
 13807  11086
             retval.tree = root_0;
 13808  11086
             RewriteRuleTokenStream stream_i=new RewriteRuleTokenStream(adaptor,"token i",i);
 13809  11086
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13810  
 
 13811  11086
             root_0 = (Object)adaptor.nil();
 13812  
             // 439:24: -> ^( PATH_ELT_OR_INVERSE ( $i)? pathElt )
 13813  
             {
 13814  
                 // com\\googlecode\\sparkleg\\Sparql.g:439:27: ^( PATH_ELT_OR_INVERSE ( $i)? pathElt )
 13815  
                 {
 13816  13862
                 Object root_1 = (Object)adaptor.nil();
 13817  13862
                 root_1 = (Object)adaptor.becomeRoot(
 13818  
                 (Object)adaptor.create(PATH_ELT_OR_INVERSE, "PATH_ELT_OR_INVERSE")
 13819  
                 , root_1);
 13820  2776
 
 13821  
                 // com\\googlecode\\sparkleg\\Sparql.g:439:50: ( $i)?
 13822  13862
                 if ( stream_i.hasNext() ) {
 13823  48
                     adaptor.addChild(root_1, stream_i.nextNode());
 13824  2776
 
 13825  
                 }
 13826  11086
                 stream_i.reset();
 13827  
 
 13828  11086
                 adaptor.addChild(root_1, stream_pathElt.nextTree());
 13829  
 
 13830  11086
                 adaptor.addChild(root_0, root_1);
 13831  
                 }
 13832  2776
 
 13833  
             }
 13834  
 
 13835  2776
 
 13836  13862
             retval.tree = root_0;
 13837  
 
 13838  2776
             }
 13839  
 
 13840  13862
             retval.stop = input.LT(-1);
 13841  
 
 13842  
 
 13843  13862
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13844  13862
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13845  
 
 13846  
         }
 13847  0
         catch (RecognitionException re) {
 13848  0
             reportError(re);
 13849  0
             recover(input,re);
 13850  66
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13851  
 
 13852  
         }
 13853  
 
 13854  0
         finally {
 13855  2776
                 // do for sure before leaving
 13856  11086
         }
 13857  11086
         return retval;
 13858  
     }
 13859  66
     // $ANTLR end "pathEltOrInverse"
 13860  66
 
 13861  
 
 13862  66
     public static class pathElt_return extends ParserRuleReturnScope {
 13863  
         Object tree;
 13864  66
         public Object getTree() { return tree; }
 13865  
     };
 13866  
 
 13867  
 
 13868  
     // $ANTLR start "pathElt"
 13869  
     // com\\googlecode\\sparkleg\\Sparql.g:442:1: pathElt : pathPrimary ( pathMod )? ;
 13870  
     public final SparqlParser.pathElt_return pathElt() throws RecognitionException {
 13871  11086
         SparqlParser.pathElt_return retval = new SparqlParser.pathElt_return();
 13872  11086
         retval.start = input.LT(1);
 13873  
 
 13874  2776
 
 13875  11086
         Object root_0 = null;
 13876  
 
 13877  13862
         SparqlParser.pathPrimary_return pathPrimary300 =null;
 13878  2776
 
 13879  11086
         SparqlParser.pathMod_return pathMod301 =null;
 13880  
 
 13881  
 
 13882  
 
 13883  
         try {
 13884  
             // com\\googlecode\\sparkleg\\Sparql.g:443:5: ( pathPrimary ( pathMod )? )
 13885  
             // com\\googlecode\\sparkleg\\Sparql.g:443:7: pathPrimary ( pathMod )?
 13886  
             {
 13887  11086
             root_0 = (Object)adaptor.nil();
 13888  
 
 13889  
 
 13890  13862
             pushFollow(FOLLOW_pathPrimary_in_pathElt3562);
 13891  13862
             pathPrimary300=pathPrimary();
 13892  
 
 13893  11086
             state._fsp--;
 13894  
 
 13895  11086
             adaptor.addChild(root_0, pathPrimary300.getTree());
 13896  66
 
 13897  
             // com\\googlecode\\sparkleg\\Sparql.g:443:19: ( pathMod )?
 13898  11086
             int alt101=2;
 13899  11086
             switch ( input.LA(1) ) {
 13900  
                 case ASTERISK:
 13901  
                 case PLUS:
 13902  
                 case QUESTION_MARK:
 13903  
                 case 216:
 13904  
                     {
 13905  330
                     alt101=1;
 13906  66
                     }
 13907  
                     break;
 13908  
             }
 13909  66
 
 13910  11086
             switch (alt101) {
 13911  66
                 case 1 :
 13912  66
                     // com\\googlecode\\sparkleg\\Sparql.g:443:19: pathMod
 13913  66
                     {
 13914  330
                     pushFollow(FOLLOW_pathMod_in_pathElt3564);
 13915  330
                     pathMod301=pathMod();
 13916  66
 
 13917  330
                     state._fsp--;
 13918  66
 
 13919  330
                     adaptor.addChild(root_0, pathMod301.getTree());
 13920  66
 
 13921  66
                     }
 13922  66
                     break;
 13923  66
 
 13924  
             }
 13925  66
 
 13926  66
 
 13927  66
             }
 13928  66
 
 13929  11152
             retval.stop = input.LT(-1);
 13930  66
 
 13931  66
 
 13932  11152
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13933  11152
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13934  66
 
 13935  66
         }
 13936  66
         catch (RecognitionException re) {
 13937  66
             reportError(re);
 13938  0
             recover(input,re);
 13939  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13940  
 
 13941  
         }
 13942  
 
 13943  66
         finally {
 13944  
                 // do for sure before leaving
 13945  11086
         }
 13946  11086
         return retval;
 13947  66
     }
 13948  66
     // $ANTLR end "pathElt"
 13949  
 
 13950  
 
 13951  18
     public static class pathMod_return extends ParserRuleReturnScope {
 13952  
         Object tree;
 13953  18
         public Object getTree() { return tree; }
 13954  
     };
 13955  
 
 13956  2
 
 13957  
     // $ANTLR start "pathMod"
 13958  2
     // com\\googlecode\\sparkleg\\Sparql.g:446:1: pathMod : ( '*' -> PATH_MOD '*' | '?' -> PATH_MOD '?' | '+' -> PATH_MOD '+' | '{' i1= INTEGER '}' -> PATH_MOD $i1| '{' i1= INTEGER c= ',' '}' -> PATH_MOD $i1 $c| '{' i1= INTEGER ',' i2= INTEGER '}' -> PATH_MOD $i1 $i2| '{' c= ',' i2= INTEGER '}' -> PATH_MOD $c $i2);
 13959  
     public final SparqlParser.pathMod_return pathMod() throws RecognitionException {
 13960  264
         SparqlParser.pathMod_return retval = new SparqlParser.pathMod_return();
 13961  280
         retval.start = input.LT(1);
 13962  
 
 13963  16
 
 13964  264
         Object root_0 = null;
 13965  
 
 13966  294
         Token i1=null;
 13967  264
         Token c=null;
 13968  294
         Token i2=null;
 13969  264
         Token char_literal302=null;
 13970  264
         Token char_literal303=null;
 13971  264
         Token char_literal304=null;
 13972  264
         Token char_literal305=null;
 13973  264
         Token char_literal306=null;
 13974  264
         Token char_literal307=null;
 13975  264
         Token char_literal308=null;
 13976  264
         Token char_literal309=null;
 13977  330
         Token char_literal310=null;
 13978  264
         Token char_literal311=null;
 13979  264
         Token char_literal312=null;
 13980  264
         Token char_literal313=null;
 13981  18
 
 13982  282
         Object i1_tree=null;
 13983  264
         Object c_tree=null;
 13984  264
         Object i2_tree=null;
 13985  282
         Object char_literal302_tree=null;
 13986  264
         Object char_literal303_tree=null;
 13987  264
         Object char_literal304_tree=null;
 13988  264
         Object char_literal305_tree=null;
 13989  282
         Object char_literal306_tree=null;
 13990  264
         Object char_literal307_tree=null;
 13991  264
         Object char_literal308_tree=null;
 13992  264
         Object char_literal309_tree=null;
 13993  266
         Object char_literal310_tree=null;
 13994  266
         Object char_literal311_tree=null;
 13995  264
         Object char_literal312_tree=null;
 13996  264
         Object char_literal313_tree=null;
 13997  266
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 13998  264
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 13999  264
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 14000  264
         RewriteRuleTokenStream stream_216=new RewriteRuleTokenStream(adaptor,"token 216");
 14001  266
         RewriteRuleTokenStream stream_218=new RewriteRuleTokenStream(adaptor,"token 218");
 14002  264
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 14003  264
         RewriteRuleTokenStream stream_QUESTION_MARK=new RewriteRuleTokenStream(adaptor,"token QUESTION_MARK");
 14004  
 
 14005  16
         try {
 14006  16
             // com\\googlecode\\sparkleg\\Sparql.g:447:5: ( '*' -> PATH_MOD '*' | '?' -> PATH_MOD '?' | '+' -> PATH_MOD '+' | '{' i1= INTEGER '}' -> PATH_MOD $i1| '{' i1= INTEGER c= ',' '}' -> PATH_MOD $i1 $c| '{' i1= INTEGER ',' i2= INTEGER '}' -> PATH_MOD $i1 $i2| '{' c= ',' i2= INTEGER '}' -> PATH_MOD $c $i2)
 14007  264
             int alt102=7;
 14008  264
             switch ( input.LA(1) ) {
 14009  16
             case ASTERISK:
 14010  
                 {
 14011  72
                 alt102=1;
 14012  
                 }
 14013  88
                 break;
 14014  
             case QUESTION_MARK:
 14015  
                 {
 14016  8
                 alt102=2;
 14017  30
                 }
 14018  38
                 break;
 14019  
             case PLUS:
 14020  
                 {
 14021  94
                 alt102=3;
 14022  
                 }
 14023  64
                 break;
 14024  
             case 216:
 14025  30
                 {
 14026  150
                 switch ( input.LA(2) ) {
 14027  
                 case INTEGER:
 14028  
                     {
 14029  140
                     switch ( input.LA(3) ) {
 14030  
                     case 218:
 14031  28
                         {
 14032  72
                         alt102=4;
 14033  
                         }
 14034  74
                         break;
 14035  
                     case 211:
 14036  2
                         {
 14037  40
                         switch ( input.LA(4) ) {
 14038  
                         case 218:
 14039  
                             {
 14040  24
                             alt102=5;
 14041  
                             }
 14042  24
                             break;
 14043  
                         case INTEGER:
 14044  
                             {
 14045  46
                             alt102=6;
 14046  
                             }
 14047  16
                             break;
 14048  
                         default:
 14049  28
                             NoViableAltException nvae =
 14050  28
                                 new NoViableAltException("", 102, 8, input);
 14051  
 
 14052  0
                             throw nvae;
 14053  28
 
 14054  
                         }
 14055  
 
 14056  
                         }
 14057  68
                         break;
 14058  28
                     default:
 14059  0
                         NoViableAltException nvae =
 14060  
                             new NoViableAltException("", 102, 5, input);
 14061  10
 
 14062  0
                         throw nvae;
 14063  10
 
 14064  
                     }
 14065  
 
 14066  18
                     }
 14067  112
                     break;
 14068  18
                 case 211:
 14069  
                     {
 14070  8
                     alt102=7;
 14071  
                     }
 14072  8
                     break;
 14073  
                 default:
 14074  0
                     NoViableAltException nvae =
 14075  
                         new NoViableAltException("", 102, 4, input);
 14076  
 
 14077  28
                     throw nvae;
 14078  
 
 14079  
                 }
 14080  
 
 14081  10
                 }
 14082  130
                 break;
 14083  
             default:
 14084  0
                 NoViableAltException nvae =
 14085  10
                     new NoViableAltException("", 102, 0, input);
 14086  
 
 14087  0
                 throw nvae;
 14088  
 
 14089  10
             }
 14090  10
 
 14091  264
             switch (alt102) {
 14092  
                 case 1 :
 14093  6
                     // com\\googlecode\\sparkleg\\Sparql.g:447:7: '*'
 14094  
                     {
 14095  78
                     char_literal302=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod3582);  
 14096  72
                     stream_ASTERISK.add(char_literal302);
 14097  
 
 14098  4
 
 14099  
                     // AST REWRITE
 14100  4
                     // elements: ASTERISK
 14101  
                     // token labels: 
 14102  
                     // rule labels: retval
 14103  
                     // token list labels: 
 14104  
                     // rule list labels: 
 14105  
                     // wildcard labels: 
 14106  72
                     retval.tree = root_0;
 14107  72
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14108  
 
 14109  82
                     root_0 = (Object)adaptor.nil();
 14110  
                     // 447:11: -> PATH_MOD '*'
 14111  
                     {
 14112  72
                         adaptor.addChild(root_0, 
 14113  6
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14114  6
                         );
 14115  
 
 14116  72
                         adaptor.addChild(root_0, 
 14117  6
                         stream_ASTERISK.nextNode()
 14118  
                         );
 14119  
 
 14120  
                     }
 14121  6
 
 14122  
 
 14123  72
                     retval.tree = root_0;
 14124  
 
 14125  4
                     }
 14126  76
                     break;
 14127  
                 case 2 :
 14128  
                     // com\\googlecode\\sparkleg\\Sparql.g:448:7: '?'
 14129  4
                     {
 14130  8
                     char_literal303=(Token)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod3596);  
 14131  8
                     stream_QUESTION_MARK.add(char_literal303);
 14132  4
 
 14133  4
 
 14134  
                     // AST REWRITE
 14135  
                     // elements: QUESTION_MARK
 14136  4
                     // token labels: 
 14137  
                     // rule labels: retval
 14138  
                     // token list labels: 
 14139  
                     // rule list labels: 
 14140  
                     // wildcard labels: 
 14141  8
                     retval.tree = root_0;
 14142  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14143  
 
 14144  8
                     root_0 = (Object)adaptor.nil();
 14145  
                     // 448:11: -> PATH_MOD '?'
 14146  10
                     {
 14147  8
                         adaptor.addChild(root_0, 
 14148  
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14149  
                         );
 14150  18
 
 14151  26
                         adaptor.addChild(root_0, 
 14152  
                         stream_QUESTION_MARK.nextNode()
 14153  
                         );
 14154  18
 
 14155  
                     }
 14156  
 
 14157  
 
 14158  8
                     retval.tree = root_0;
 14159  
 
 14160  
                     }
 14161  8
                     break;
 14162  
                 case 3 :
 14163  
                     // com\\googlecode\\sparkleg\\Sparql.g:449:7: '+'
 14164  28
                     {
 14165  64
                     char_literal304=(Token)match(input,PLUS,FOLLOW_PLUS_in_pathMod3611);  
 14166  64
                     stream_PLUS.add(char_literal304);
 14167  
 
 14168  2
 
 14169  2
                     // AST REWRITE
 14170  
                     // elements: PLUS
 14171  
                     // token labels: 
 14172  2
                     // rule labels: retval
 14173  
                     // token list labels: 
 14174  
                     // rule list labels: 
 14175  2
                     // wildcard labels: 
 14176  66
                     retval.tree = root_0;
 14177  64
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14178  
 
 14179  66
                     root_0 = (Object)adaptor.nil();
 14180  
                     // 449:11: -> PATH_MOD '+'
 14181  
                     {
 14182  66
                         adaptor.addChild(root_0, 
 14183  2
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14184  
                         );
 14185  
 
 14186  66
                         adaptor.addChild(root_0, 
 14187  
                         stream_PLUS.nextNode()
 14188  
                         );
 14189  
 
 14190  
                     }
 14191  
 
 14192  
 
 14193  64
                     retval.tree = root_0;
 14194  
 
 14195  
                     }
 14196  64
                     break;
 14197  
                 case 4 :
 14198  
                     // com\\googlecode\\sparkleg\\Sparql.g:450:7: '{' i1= INTEGER '}'
 14199  
                     {
 14200  72
                     char_literal305=(Token)match(input,216,FOLLOW_216_in_pathMod3626);  
 14201  72
                     stream_216.add(char_literal305);
 14202  
 
 14203  66
 
 14204  72
                     i1=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3630);  
 14205  72
                     stream_INTEGER.add(i1);
 14206  66
 
 14207  66
 
 14208  72
                     char_literal306=(Token)match(input,218,FOLLOW_218_in_pathMod3632);  
 14209  72
                     stream_218.add(char_literal306);
 14210  
 
 14211  
 
 14212  
                     // AST REWRITE
 14213  
                     // elements: i1
 14214  
                     // token labels: i1
 14215  
                     // rule labels: retval
 14216  
                     // token list labels: 
 14217  
                     // rule list labels: 
 14218  
                     // wildcard labels: 
 14219  138
                     retval.tree = root_0;
 14220  138
                     RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
 14221  72
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14222  
 
 14223  72
                     root_0 = (Object)adaptor.nil();
 14224  
                     // 450:26: -> PATH_MOD $i1
 14225  2776
                     {
 14226  72
                         adaptor.addChild(root_0, 
 14227  2776
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14228  
                         );
 14229  
 
 14230  72
                         adaptor.addChild(root_0, stream_i1.nextNode());
 14231  
 
 14232  
                     }
 14233  
 
 14234  2776
 
 14235  2848
                     retval.tree = root_0;
 14236  
 
 14237  
                     }
 14238  2848
                     break;
 14239  
                 case 5 :
 14240  2776
                     // com\\googlecode\\sparkleg\\Sparql.g:451:7: '{' i1= INTEGER c= ',' '}'
 14241  2776
                     {
 14242  2800
                     char_literal307=(Token)match(input,216,FOLLOW_216_in_pathMod3647);  
 14243  2800
                     stream_216.add(char_literal307);
 14244  2776
 
 14245  
 
 14246  2800
                     i1=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3651);  
 14247  24
                     stream_INTEGER.add(i1);
 14248  2776
 
 14249  
 
 14250  24
                     c=(Token)match(input,211,FOLLOW_211_in_pathMod3655);  
 14251  2800
                     stream_211.add(c);
 14252  2776
 
 14253  2776
 
 14254  2800
                     char_literal308=(Token)match(input,218,FOLLOW_218_in_pathMod3657);  
 14255  2800
                     stream_218.add(char_literal308);
 14256  2776
 
 14257  2776
 
 14258  2776
                     // AST REWRITE
 14259  2776
                     // elements: c, i1
 14260  2776
                     // token labels: c, i1
 14261  2776
                     // rule labels: retval
 14262  
                     // token list labels: 
 14263  
                     // rule list labels: 
 14264  2776
                     // wildcard labels: 
 14265  2800
                     retval.tree = root_0;
 14266  24
                     RewriteRuleTokenStream stream_c=new RewriteRuleTokenStream(adaptor,"token c",c);
 14267  24
                     RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
 14268  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14269  
 
 14270  2710
                     root_0 = (Object)adaptor.nil();
 14271  
                     // 451:32: -> PATH_MOD $i1 $c
 14272  2686
                     {
 14273  24
                         adaptor.addChild(root_0, 
 14274  
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14275  64
                         );
 14276  
 
 14277  88
                         adaptor.addChild(root_0, stream_i1.nextNode());
 14278  
 
 14279  24
                         adaptor.addChild(root_0, stream_c.nextNode());
 14280  6
 
 14281  
                     }
 14282  6
 
 14283  
 
 14284  24
                     retval.tree = root_0;
 14285  20
 
 14286  
                     }
 14287  44
                     break;
 14288  
                 case 6 :
 14289  
                     // com\\googlecode\\sparkleg\\Sparql.g:452:7: '{' i1= INTEGER ',' i2= INTEGER '}'
 14290  
                     {
 14291  16
                     char_literal309=(Token)match(input,216,FOLLOW_216_in_pathMod3675);  
 14292  16
                     stream_216.add(char_literal309);
 14293  
 
 14294  
 
 14295  16
                     i1=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3679);  
 14296  2792
                     stream_INTEGER.add(i1);
 14297  
 
 14298  
 
 14299  16
                     char_literal310=(Token)match(input,211,FOLLOW_211_in_pathMod3681);  
 14300  2702
                     stream_211.add(char_literal310);
 14301  2686
 
 14302  
 
 14303  2702
                     i2=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3685);  
 14304  16
                     stream_INTEGER.add(i2);
 14305  2686
 
 14306  
 
 14307  16
                     char_literal311=(Token)match(input,218,FOLLOW_218_in_pathMod3687);  
 14308  16
                     stream_218.add(char_literal311);
 14309  
 
 14310  
 
 14311  
                     // AST REWRITE
 14312  
                     // elements: i1, i2
 14313  
                     // token labels: i2, i1
 14314  2686
                     // rule labels: retval
 14315  2686
                     // token list labels: 
 14316  
                     // rule list labels: 
 14317  2686
                     // wildcard labels: 
 14318  16
                     retval.tree = root_0;
 14319  16
                     RewriteRuleTokenStream stream_i2=new RewriteRuleTokenStream(adaptor,"token i2",i2);
 14320  16
                     RewriteRuleTokenStream stream_i1=new RewriteRuleTokenStream(adaptor,"token i1",i1);
 14321  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14322  2686
 
 14323  2702
                     root_0 = (Object)adaptor.nil();
 14324  
                     // 452:42: -> PATH_MOD $i1 $i2
 14325  
                     {
 14326  16
                         adaptor.addChild(root_0, 
 14327  2686
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14328  
                         );
 14329  2686
 
 14330  16
                         adaptor.addChild(root_0, stream_i1.nextNode());
 14331  
 
 14332  16
                         adaptor.addChild(root_0, stream_i2.nextNode());
 14333  
 
 14334  
                     }
 14335  2686
 
 14336  
 
 14337  16
                     retval.tree = root_0;
 14338  2686
 
 14339  
                     }
 14340  16
                     break;
 14341  
                 case 7 :
 14342  64
                     // com\\googlecode\\sparkleg\\Sparql.g:453:7: '{' c= ',' i2= INTEGER '}'
 14343  64
                     {
 14344  8
                     char_literal312=(Token)match(input,216,FOLLOW_216_in_pathMod3706);  
 14345  8
                     stream_216.add(char_literal312);
 14346  
 
 14347  
 
 14348  8
                     c=(Token)match(input,211,FOLLOW_211_in_pathMod3710);  
 14349  8
                     stream_211.add(c);
 14350  
 
 14351  
 
 14352  8
                     i2=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3714);  
 14353  72
                     stream_INTEGER.add(i2);
 14354  64
 
 14355  
 
 14356  72
                     char_literal313=(Token)match(input,218,FOLLOW_218_in_pathMod3716);  
 14357  8
                     stream_218.add(char_literal313);
 14358  
 
 14359  
 
 14360  
                     // AST REWRITE
 14361  64
                     // elements: c, i2
 14362  64
                     // token labels: c, i2
 14363  
                     // rule labels: retval
 14364  
                     // token list labels: 
 14365  
                     // rule list labels: 
 14366  64
                     // wildcard labels: 
 14367  8
                     retval.tree = root_0;
 14368  8
                     RewriteRuleTokenStream stream_c=new RewriteRuleTokenStream(adaptor,"token c",c);
 14369  8
                     RewriteRuleTokenStream stream_i2=new RewriteRuleTokenStream(adaptor,"token i2",i2);
 14370  72
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14371  
 
 14372  8
                     root_0 = (Object)adaptor.nil();
 14373  
                     // 453:32: -> PATH_MOD $c $i2
 14374  
                     {
 14375  8
                         adaptor.addChild(root_0, 
 14376  64
                         (Object)adaptor.create(PATH_MOD, "PATH_MOD")
 14377  
                         );
 14378  
 
 14379  72
                         adaptor.addChild(root_0, stream_c.nextNode());
 14380  
 
 14381  8
                         adaptor.addChild(root_0, stream_i2.nextNode());
 14382  
 
 14383  6
                     }
 14384  6
 
 14385  
 
 14386  8
                     retval.tree = root_0;
 14387  6
 
 14388  6
                     }
 14389  
                     break;
 14390  6
 
 14391  
             }
 14392  270
             retval.stop = input.LT(-1);
 14393  
 
 14394  
 
 14395  264
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14396  264
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14397  
 
 14398  
         }
 14399  0
         catch (RecognitionException re) {
 14400  0
             reportError(re);
 14401  6
             recover(input,re);
 14402  6
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14403  
 
 14404  6
         }
 14405  
 
 14406  0
         finally {
 14407  
                 // do for sure before leaving
 14408  264
         }
 14409  270
         return retval;
 14410  6
     }
 14411  
     // $ANTLR end "pathMod"
 14412  
 
 14413  
 
 14414  6
     public static class pathPrimary_return extends ParserRuleReturnScope {
 14415  
         Object tree;
 14416  11086
         public Object getTree() { return tree; }
 14417  
     };
 14418  6
 
 14419  
 
 14420  6
     // $ANTLR start "pathPrimary"
 14421  
     // com\\googlecode\\sparkleg\\Sparql.g:456:1: pathPrimary : ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | '!' pathNegatedPropertySet -> ^( PATH_PRIMARY pathNegatedPropertySet ) | '(' path ')' -> ^( PATH_PRIMARY path ) );
 14422  
     public final SparqlParser.pathPrimary_return pathPrimary() throws RecognitionException {
 14423  11086
         SparqlParser.pathPrimary_return retval = new SparqlParser.pathPrimary_return();
 14424  11086
         retval.start = input.LT(1);
 14425  
 
 14426  6
 
 14427  11086
         Object root_0 = null;
 14428  
 
 14429  11092
         Token A315=null;
 14430  11086
         Token char_literal316=null;
 14431  11086
         Token char_literal318=null;
 14432  11086
         Token char_literal320=null;
 14433  11106
         SparqlParser.iriRef_return iriRef314 =null;
 14434  20
 
 14435  11086
         SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet317 =null;
 14436  
 
 14437  11106
         SparqlParser.path_return path319 =null;
 14438  20
 
 14439  
 
 14440  11106
         Object A315_tree=null;
 14441  11086
         Object char_literal316_tree=null;
 14442  11106
         Object char_literal318_tree=null;
 14443  11086
         Object char_literal320_tree=null;
 14444  11106
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 14445  11106
         RewriteRuleTokenStream stream_A=new RewriteRuleTokenStream(adaptor,"token A");
 14446  11086
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 14447  11086
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 14448  11086
         RewriteRuleSubtreeStream stream_path=new RewriteRuleSubtreeStream(adaptor,"rule path");
 14449  11086
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 14450  11086
         RewriteRuleSubtreeStream stream_pathNegatedPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathNegatedPropertySet");
 14451  
         try {
 14452  
             // com\\googlecode\\sparkleg\\Sparql.g:457:5: ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | '!' pathNegatedPropertySet -> ^( PATH_PRIMARY pathNegatedPropertySet ) | '(' path ')' -> ^( PATH_PRIMARY path ) )
 14453  11086
             int alt103=4;
 14454  11086
             switch ( input.LA(1) ) {
 14455  20
             case IRI_REF:
 14456  20
             case PNAME_LN:
 14457  
             case PNAME_NS:
 14458  20
                 {
 14459  10726
                 alt103=1;
 14460  
                 }
 14461  10726
                 break;
 14462  
             case A:
 14463  20
                 {
 14464  276
                 alt103=2;
 14465  
                 }
 14466  256
                 break;
 14467  
             case NEGATION:
 14468  20
                 {
 14469  24
                 alt103=3;
 14470  20
                 }
 14471  24
                 break;
 14472  
             case 209:
 14473  
                 {
 14474  80
                 alt103=4;
 14475  
                 }
 14476  100
                 break;
 14477  
             default:
 14478  0
                 NoViableAltException nvae =
 14479  
                     new NoViableAltException("", 103, 0, input);
 14480  
 
 14481  0
                 throw nvae;
 14482  2776
 
 14483  
             }
 14484  
 
 14485  13862
             switch (alt103) {
 14486  2776
                 case 1 :
 14487  
                     // com\\googlecode\\sparkleg\\Sparql.g:457:7: iriRef
 14488  
                     {
 14489  10726
                     pushFollow(FOLLOW_iriRef_in_pathPrimary3743);
 14490  10726
                     iriRef314=iriRef();
 14491  
 
 14492  10726
                     state._fsp--;
 14493  
 
 14494  10726
                     stream_iriRef.add(iriRef314.getTree());
 14495  
 
 14496  
                     // AST REWRITE
 14497  
                     // elements: iriRef
 14498  2776
                     // token labels: 
 14499  2776
                     // rule labels: retval
 14500  
                     // token list labels: 
 14501  
                     // rule list labels: 
 14502  
                     // wildcard labels: 
 14503  10726
                     retval.tree = root_0;
 14504  10726
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14505  
 
 14506  10726
                     root_0 = (Object)adaptor.nil();
 14507  
                     // 457:14: -> ^( PATH_PRIMARY iriRef )
 14508  
                     {
 14509  
                         // com\\googlecode\\sparkleg\\Sparql.g:457:17: ^( PATH_PRIMARY iriRef )
 14510  
                         {
 14511  10726
                         Object root_1 = (Object)adaptor.nil();
 14512  10726
                         root_1 = (Object)adaptor.becomeRoot(
 14513  6
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14514  6
                         , root_1);
 14515  
 
 14516  10726
                         adaptor.addChild(root_1, stream_iriRef.nextTree());
 14517  6
 
 14518  10726
                         adaptor.addChild(root_0, root_1);
 14519  6
                         }
 14520  6
 
 14521  6
                     }
 14522  6
 
 14523  
 
 14524  10732
                     retval.tree = root_0;
 14525  
 
 14526  6
                     }
 14527  10726
                     break;
 14528  
                 case 2 :
 14529  6
                     // com\\googlecode\\sparkleg\\Sparql.g:458:7: A
 14530  6
                     {
 14531  262
                     A315=(Token)match(input,A,FOLLOW_A_in_pathPrimary3759);  
 14532  262
                     stream_A.add(A315);
 14533  6
 
 14534  6
 
 14535  6
                     // AST REWRITE
 14536  
                     // elements: A
 14537  
                     // token labels: 
 14538  6
                     // rule labels: retval
 14539  6
                     // token list labels: 
 14540  
                     // rule list labels: 
 14541  
                     // wildcard labels: 
 14542  256
                     retval.tree = root_0;
 14543  256
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14544  
 
 14545  256
                     root_0 = (Object)adaptor.nil();
 14546  
                     // 458:9: -> ^( PATH_PRIMARY A )
 14547  
                     {
 14548  
                         // com\\googlecode\\sparkleg\\Sparql.g:458:12: ^( PATH_PRIMARY A )
 14549  
                         {
 14550  256
                         Object root_1 = (Object)adaptor.nil();
 14551  262
                         root_1 = (Object)adaptor.becomeRoot(
 14552  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14553  6
                         , root_1);
 14554  
 
 14555  256
                         adaptor.addChild(root_1, 
 14556  
                         stream_A.nextNode()
 14557  
                         );
 14558  
 
 14559  256
                         adaptor.addChild(root_0, root_1);
 14560  
                         }
 14561  
 
 14562  6
                     }
 14563  
 
 14564  
 
 14565  256
                     retval.tree = root_0;
 14566  
 
 14567  
                     }
 14568  256
                     break;
 14569  
                 case 3 :
 14570  
                     // com\\googlecode\\sparkleg\\Sparql.g:459:7: '!' pathNegatedPropertySet
 14571  
                     {
 14572  24
                     char_literal316=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary3775);  
 14573  24
                     stream_NEGATION.add(char_literal316);
 14574  
 
 14575  
 
 14576  24
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary3777);
 14577  24
                     pathNegatedPropertySet317=pathNegatedPropertySet();
 14578  
 
 14579  24
                     state._fsp--;
 14580  
 
 14581  24
                     stream_pathNegatedPropertySet.add(pathNegatedPropertySet317.getTree());
 14582  
 
 14583  
                     // AST REWRITE
 14584  
                     // elements: pathNegatedPropertySet
 14585  
                     // token labels: 
 14586  
                     // rule labels: retval
 14587  
                     // token list labels: 
 14588  
                     // rule list labels: 
 14589  
                     // wildcard labels: 
 14590  24
                     retval.tree = root_0;
 14591  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14592  
 
 14593  24
                     root_0 = (Object)adaptor.nil();
 14594  
                     // 459:34: -> ^( PATH_PRIMARY pathNegatedPropertySet )
 14595  
                     {
 14596  
                         // com\\googlecode\\sparkleg\\Sparql.g:459:37: ^( PATH_PRIMARY pathNegatedPropertySet )
 14597  
                         {
 14598  24
                         Object root_1 = (Object)adaptor.nil();
 14599  24
                         root_1 = (Object)adaptor.becomeRoot(
 14600  
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14601  
                         , root_1);
 14602  
 
 14603  24
                         adaptor.addChild(root_1, stream_pathNegatedPropertySet.nextTree());
 14604  
 
 14605  24
                         adaptor.addChild(root_0, root_1);
 14606  
                         }
 14607  
 
 14608  6
                     }
 14609  6
 
 14610  
 
 14611  24
                     retval.tree = root_0;
 14612  
 
 14613  6
                     }
 14614  30
                     break;
 14615  
                 case 4 :
 14616  
                     // com\\googlecode\\sparkleg\\Sparql.g:460:7: '(' path ')'
 14617  
                     {
 14618  80
                     char_literal318=(Token)match(input,209,FOLLOW_209_in_pathPrimary3793);  
 14619  80
                     stream_209.add(char_literal318);
 14620  
 
 14621  6
 
 14622  80
                     pushFollow(FOLLOW_path_in_pathPrimary3795);
 14623  80
                     path319=path();
 14624  
 
 14625  80
                     state._fsp--;
 14626  6
 
 14627  80
                     stream_path.add(path319.getTree());
 14628  
 
 14629  80
                     char_literal320=(Token)match(input,210,FOLLOW_210_in_pathPrimary3797);  
 14630  86
                     stream_210.add(char_literal320);
 14631  6
 
 14632  
 
 14633  6
                     // AST REWRITE
 14634  
                     // elements: path
 14635  6
                     // token labels: 
 14636  
                     // rule labels: retval
 14637  
                     // token list labels: 
 14638  
                     // rule list labels: 
 14639  
                     // wildcard labels: 
 14640  92
                     retval.tree = root_0;
 14641  92
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14642  
 
 14643  80
                     root_0 = (Object)adaptor.nil();
 14644  6
                     // 460:20: -> ^( PATH_PRIMARY path )
 14645  
                     {
 14646  
                         // com\\googlecode\\sparkleg\\Sparql.g:460:23: ^( PATH_PRIMARY path )
 14647  
                         {
 14648  80
                         Object root_1 = (Object)adaptor.nil();
 14649  80
                         root_1 = (Object)adaptor.becomeRoot(
 14650  12
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14651  
                         , root_1);
 14652  
 
 14653  80
                         adaptor.addChild(root_1, stream_path.nextTree());
 14654  6
 
 14655  86
                         adaptor.addChild(root_0, root_1);
 14656  
                         }
 14657  
 
 14658  6
                     }
 14659  6
 
 14660  
 
 14661  86
                     retval.tree = root_0;
 14662  
 
 14663  6
                     }
 14664  
                     break;
 14665  
 
 14666  6
             }
 14667  11086
             retval.stop = input.LT(-1);
 14668  
 
 14669  6
 
 14670  11086
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14671  11092
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14672  
 
 14673  
         }
 14674  0
         catch (RecognitionException re) {
 14675  0
             reportError(re);
 14676  0
             recover(input,re);
 14677  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14678  
 
 14679  
         }
 14680  6
 
 14681  6
         finally {
 14682  
                 // do for sure before leaving
 14683  11086
         }
 14684  11086
         return retval;
 14685  
     }
 14686  
     // $ANTLR end "pathPrimary"
 14687  
 
 14688  
 
 14689  24
     public static class pathNegatedPropertySet_return extends ParserRuleReturnScope {
 14690  
         Object tree;
 14691  6
         public Object getTree() { return tree; }
 14692  6
     };
 14693  
 
 14694  6
 
 14695  
     // $ANTLR start "pathNegatedPropertySet"
 14696  
     // com\\googlecode\\sparkleg\\Sparql.g:463:1: pathNegatedPropertySet : ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | '(' ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )? ')' -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) );
 14697  
     public final SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 14698  24
         SparqlParser.pathNegatedPropertySet_return retval = new SparqlParser.pathNegatedPropertySet_return();
 14699  30
         retval.start = input.LT(1);
 14700  6
 
 14701  
 
 14702  24
         Object root_0 = null;
 14703  
 
 14704  30
         Token char_literal322=null;
 14705  24
         Token char_literal324=null;
 14706  24
         Token char_literal326=null;
 14707  42
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet321 =null;
 14708  12
 
 14709  24
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet323 =null;
 14710  
 
 14711  30
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet325 =null;
 14712  
 
 14713  6
 
 14714  24
         Object char_literal322_tree=null;
 14715  24
         Object char_literal324_tree=null;
 14716  24
         Object char_literal326_tree=null;
 14717  24
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 14718  24
         RewriteRuleTokenStream stream_217=new RewriteRuleTokenStream(adaptor,"token 217");
 14719  30
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 14720  24
         RewriteRuleSubtreeStream stream_pathOneInPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathOneInPropertySet");
 14721  
         try {
 14722  
             // com\\googlecode\\sparkleg\\Sparql.g:464:5: ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | '(' ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )? ')' -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 14723  24
             int alt106=2;
 14724  24
             switch ( input.LA(1) ) {
 14725  6
             case A:
 14726  
             case INVERSE:
 14727  
             case IRI_REF:
 14728  6
             case PNAME_LN:
 14729  6
             case PNAME_NS:
 14730  
                 {
 14731  0
                 alt106=1;
 14732  
                 }
 14733  0
                 break;
 14734  
             case 209:
 14735  
                 {
 14736  24
                 alt106=2;
 14737  
                 }
 14738  24
                 break;
 14739  
             default:
 14740  0
                 NoViableAltException nvae =
 14741  6
                     new NoViableAltException("", 106, 0, input);
 14742  6
 
 14743  0
                 throw nvae;
 14744  
 
 14745  
             }
 14746  
 
 14747  24
             switch (alt106) {
 14748  
                 case 1 :
 14749  12
                     // com\\googlecode\\sparkleg\\Sparql.g:464:7: pathOneInPropertySet
 14750  
                     {
 14751  0
                     pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3822);
 14752  0
                     pathOneInPropertySet321=pathOneInPropertySet();
 14753  
 
 14754  0
                     state._fsp--;
 14755  
 
 14756  12
                     stream_pathOneInPropertySet.add(pathOneInPropertySet321.getTree());
 14757  12
 
 14758  
                     // AST REWRITE
 14759  
                     // elements: pathOneInPropertySet
 14760  12
                     // token labels: 
 14761  
                     // rule labels: retval
 14762  12
                     // token list labels: 
 14763  12
                     // rule list labels: 
 14764  12
                     // wildcard labels: 
 14765  0
                     retval.tree = root_0;
 14766  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14767  12
 
 14768  12
                     root_0 = (Object)adaptor.nil();
 14769  
                     // 464:28: -> ^( PATH_NEGATED pathOneInPropertySet )
 14770  
                     {
 14771  
                         // com\\googlecode\\sparkleg\\Sparql.g:464:31: ^( PATH_NEGATED pathOneInPropertySet )
 14772  
                         {
 14773  0
                         Object root_1 = (Object)adaptor.nil();
 14774  12
                         root_1 = (Object)adaptor.becomeRoot(
 14775  
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14776  
                         , root_1);
 14777  
 
 14778  12
                         adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14779  12
 
 14780  0
                         adaptor.addChild(root_0, root_1);
 14781  
                         }
 14782  4
 
 14783  
                     }
 14784  
 
 14785  
 
 14786  0
                     retval.tree = root_0;
 14787  12
 
 14788  
                     }
 14789  0
                     break;
 14790  
                 case 2 :
 14791  4
                     // com\\googlecode\\sparkleg\\Sparql.g:465:7: '(' ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )? ')'
 14792  4
                     {
 14793  24
                     char_literal322=(Token)match(input,209,FOLLOW_209_in_pathNegatedPropertySet3838);  
 14794  24
                     stream_209.add(char_literal322);
 14795  4
 
 14796  
 
 14797  
                     // com\\googlecode\\sparkleg\\Sparql.g:465:11: ( pathOneInPropertySet ( '|' pathOneInPropertySet )* )?
 14798  24
                     int alt105=2;
 14799  24
                     switch ( input.LA(1) ) {
 14800  
                         case A:
 14801  
                         case INVERSE:
 14802  
                         case IRI_REF:
 14803  
                         case PNAME_LN:
 14804  
                         case PNAME_NS:
 14805  12
                             {
 14806  36
                             alt105=1;
 14807  
                             }
 14808  
                             break;
 14809  
                     }
 14810  
 
 14811  36
                     switch (alt105) {
 14812  
                         case 1 :
 14813  12
                             // com\\googlecode\\sparkleg\\Sparql.g:465:12: pathOneInPropertySet ( '|' pathOneInPropertySet )*
 14814  
                             {
 14815  24
                             pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3841);
 14816  24
                             pathOneInPropertySet323=pathOneInPropertySet();
 14817  
 
 14818  24
                             state._fsp--;
 14819  
 
 14820  24
                             stream_pathOneInPropertySet.add(pathOneInPropertySet323.getTree());
 14821  
 
 14822  
                             // com\\googlecode\\sparkleg\\Sparql.g:465:33: ( '|' pathOneInPropertySet )*
 14823  
                             loop104:
 14824  
                             do {
 14825  48
                                 int alt104=2;
 14826  48
                                 switch ( input.LA(1) ) {
 14827  12
                                 case 217:
 14828  
                                     {
 14829  24
                                     alt104=1;
 14830  
                                     }
 14831  12
                                     break;
 14832  12
 
 14833  
                                 }
 14834  12
 
 14835  48
                                 switch (alt104) {
 14836  12
                                     case 1 :
 14837  
                                         // com\\googlecode\\sparkleg\\Sparql.g:465:34: '|' pathOneInPropertySet
 14838  
                                         {
 14839  36
                                         char_literal324=(Token)match(input,217,FOLLOW_217_in_pathNegatedPropertySet3844);  
 14840  24
                                         stream_217.add(char_literal324);
 14841  
 
 14842  
 
 14843  24
                                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3846);
 14844  24
                                         pathOneInPropertySet325=pathOneInPropertySet();
 14845  
 
 14846  24
                                         state._fsp--;
 14847  
 
 14848  24
                                         stream_pathOneInPropertySet.add(pathOneInPropertySet325.getTree());
 14849  
 
 14850  
                                         }
 14851  24
                                         break;
 14852  
 
 14853  
                                     default :
 14854  24
                                         break loop104;
 14855  
                                 }
 14856  24
                             } while (true);
 14857  
 
 14858  12
 
 14859  
                             }
 14860  
                             break;
 14861  12
 
 14862  12
                     }
 14863  
 
 14864  
 
 14865  24
                     char_literal326=(Token)match(input,210,FOLLOW_210_in_pathNegatedPropertySet3852);  
 14866  24
                     stream_210.add(char_literal326);
 14867  
 
 14868  
 
 14869  
                     // AST REWRITE
 14870  
                     // elements: pathOneInPropertySet
 14871  
                     // token labels: 
 14872  
                     // rule labels: retval
 14873  
                     // token list labels: 
 14874  12
                     // rule list labels: 
 14875  12
                     // wildcard labels: 
 14876  24
                     retval.tree = root_0;
 14877  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14878  
 
 14879  24
                     root_0 = (Object)adaptor.nil();
 14880  58
                     // 465:67: -> ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14881  
                     {
 14882  58
                         // com\\googlecode\\sparkleg\\Sparql.g:465:70: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14883  
                         {
 14884  24
                         Object root_1 = (Object)adaptor.nil();
 14885  24
                         root_1 = (Object)adaptor.becomeRoot(
 14886  
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14887  
                         , root_1);
 14888  
 
 14889  82
                         if ( !(stream_pathOneInPropertySet.hasNext()) ) {
 14890  58
                             throw new RewriteEarlyExitException();
 14891  
                         }
 14892  72
                         while ( stream_pathOneInPropertySet.hasNext() ) {
 14893  106
                             adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14894  
 
 14895  58
                         }
 14896  82
                         stream_pathOneInPropertySet.reset();
 14897  58
 
 14898  82
                         adaptor.addChild(root_0, root_1);
 14899  58
                         }
 14900  
 
 14901  58
                     }
 14902  
 
 14903  
 
 14904  82
                     retval.tree = root_0;
 14905  58
 
 14906  58
                     }
 14907  58
                     break;
 14908  58
 
 14909  58
             }
 14910  82
             retval.stop = input.LT(-1);
 14911  58
 
 14912  58
 
 14913  82
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14914  24
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14915  
 
 14916  58
         }
 14917  58
         catch (RecognitionException re) {
 14918  0
             reportError(re);
 14919  0
             recover(input,re);
 14920  28
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14921  
 
 14922  28
         }
 14923  
 
 14924  0
         finally {
 14925  30
                 // do for sure before leaving
 14926  24
         }
 14927  54
         return retval;
 14928  
     }
 14929  
     // $ANTLR end "pathNegatedPropertySet"
 14930  
 
 14931  
 
 14932  48
     public static class pathOneInPropertySet_return extends ParserRuleReturnScope {
 14933  
         Object tree;
 14934  48
         public Object getTree() { return tree; }
 14935  
     };
 14936  58
 
 14937  
 
 14938  
     // $ANTLR start "pathOneInPropertySet"
 14939  
     // com\\googlecode\\sparkleg\\Sparql.g:468:1: pathOneInPropertySet : ( '^' )? ( iriRef | A ) ;
 14940  28
     public final SparqlParser.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 14941  76
         SparqlParser.pathOneInPropertySet_return retval = new SparqlParser.pathOneInPropertySet_return();
 14942  48
         retval.start = input.LT(1);
 14943  
 
 14944  
 
 14945  76
         Object root_0 = null;
 14946  
 
 14947  48
         Token char_literal327=null;
 14948  114
         Token A329=null;
 14949  114
         SparqlParser.iriRef_return iriRef328 =null;
 14950  
 
 14951  
 
 14952  48
         Object char_literal327_tree=null;
 14953  48
         Object A329_tree=null;
 14954  
 
 14955  
         try {
 14956  
             // com\\googlecode\\sparkleg\\Sparql.g:469:5: ( ( '^' )? ( iriRef | A ) )
 14957  
             // com\\googlecode\\sparkleg\\Sparql.g:469:7: ( '^' )? ( iriRef | A )
 14958  
             {
 14959  48
             root_0 = (Object)adaptor.nil();
 14960  
 
 14961  
 
 14962  
             // com\\googlecode\\sparkleg\\Sparql.g:469:7: ( '^' )?
 14963  48
             int alt107=2;
 14964  48
             switch ( input.LA(1) ) {
 14965  
                 case INVERSE:
 14966  
                     {
 14967  16
                     alt107=1;
 14968  
                     }
 14969  
                     break;
 14970  
             }
 14971  
 
 14972  48
             switch (alt107) {
 14973  
                 case 1 :
 14974  38
                     // com\\googlecode\\sparkleg\\Sparql.g:469:7: '^'
 14975  
                     {
 14976  16
                     char_literal327=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet3881); 
 14977  16
                     char_literal327_tree = 
 14978  
                     (Object)adaptor.create(char_literal327)
 14979  
                     ;
 14980  82
                     adaptor.addChild(root_0, char_literal327_tree);
 14981  
 
 14982  
 
 14983  
                     }
 14984  38
                     break;
 14985  38
 
 14986  
             }
 14987  38
 
 14988  
 
 14989  38
             // com\\googlecode\\sparkleg\\Sparql.g:469:12: ( iriRef | A )
 14990  48
             int alt108=2;
 14991  48
             switch ( input.LA(1) ) {
 14992  38
             case IRI_REF:
 14993  
             case PNAME_LN:
 14994  
             case PNAME_NS:
 14995  28
                 {
 14996  48
                 alt108=1;
 14997  
                 }
 14998  48
                 break;
 14999  
             case A:
 15000  38
                 {
 15001  38
                 alt108=2;
 15002  
                 }
 15003  0
                 break;
 15004  28
             default:
 15005  28
                 NoViableAltException nvae =
 15006  
                     new NoViableAltException("", 108, 0, input);
 15007  
 
 15008  0
                 throw nvae;
 15009  
 
 15010  
             }
 15011  
 
 15012  48
             switch (alt108) {
 15013  
                 case 1 :
 15014  
                     // com\\googlecode\\sparkleg\\Sparql.g:469:13: iriRef
 15015  28
                     {
 15016  76
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet3885);
 15017  48
                     iriRef328=iriRef();
 15018  28
 
 15019  48
                     state._fsp--;
 15020  
 
 15021  48
                     adaptor.addChild(root_0, iriRef328.getTree());
 15022  
 
 15023  28
                     }
 15024  76
                     break;
 15025  
                 case 2 :
 15026  
                     // com\\googlecode\\sparkleg\\Sparql.g:469:22: A
 15027  
                     {
 15028  28
                     A329=(Token)match(input,A,FOLLOW_A_in_pathOneInPropertySet3889); 
 15029  0
                     A329_tree = 
 15030  
                     (Object)adaptor.create(A329)
 15031  66
                     ;
 15032  38
                     adaptor.addChild(root_0, A329_tree);
 15033  
 
 15034  
 
 15035  28
                     }
 15036  
                     break;
 15037  28
 
 15038  
             }
 15039  
 
 15040  
 
 15041  
             }
 15042  
 
 15043  76
             retval.stop = input.LT(-1);
 15044  
 
 15045  
 
 15046  76
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15047  48
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15048  
 
 15049  
         }
 15050  30
         catch (RecognitionException re) {
 15051  30
             reportError(re);
 15052  0
             recover(input,re);
 15053  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15054  30
 
 15055  30
         }
 15056  
 
 15057  30
         finally {
 15058  
                 // do for sure before leaving
 15059  78
         }
 15060  48
         return retval;
 15061  30
     }
 15062  30
     // $ANTLR end "pathOneInPropertySet"
 15063  
 
 15064  
 
 15065  256
     public static class triplesNode_return extends ParserRuleReturnScope {
 15066  
         Object tree;
 15067  256
         public Object getTree() { return tree; }
 15068  
     };
 15069  
 
 15070  
 
 15071  
     // $ANTLR start "triplesNode"
 15072  30
     // com\\googlecode\\sparkleg\\Sparql.g:472:1: triplesNode : ( '(' ( graphNode )+ ')' -> ^( COLLECTION ( graphNode )+ ) | '[' propertyListNotEmpty ']' -> ^( TRIPLES_NODE propertyListNotEmpty ) );
 15073  30
     public final SparqlParser.triplesNode_return triplesNode() throws RecognitionException {
 15074  256
         SparqlParser.triplesNode_return retval = new SparqlParser.triplesNode_return();
 15075  286
         retval.start = input.LT(1);
 15076  
 
 15077  
 
 15078  256
         Object root_0 = null;
 15079  
 
 15080  286
         Token char_literal330=null;
 15081  286
         Token char_literal332=null;
 15082  256
         Token char_literal333=null;
 15083  256
         Token char_literal335=null;
 15084  256
         SparqlParser.graphNode_return graphNode331 =null;
 15085  30
 
 15086  256
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty334 =null;
 15087  30
 
 15088  
 
 15089  256
         Object char_literal330_tree=null;
 15090  256
         Object char_literal332_tree=null;
 15091  256
         Object char_literal333_tree=null;
 15092  256
         Object char_literal335_tree=null;
 15093  286
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 15094  256
         RewriteRuleTokenStream stream_213=new RewriteRuleTokenStream(adaptor,"token 213");
 15095  256
         RewriteRuleTokenStream stream_214=new RewriteRuleTokenStream(adaptor,"token 214");
 15096  256
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 15097  256
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 15098  256
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 15099  58
         try {
 15100  
             // com\\googlecode\\sparkleg\\Sparql.g:473:5: ( '(' ( graphNode )+ ')' -> ^( COLLECTION ( graphNode )+ ) | '[' propertyListNotEmpty ']' -> ^( TRIPLES_NODE propertyListNotEmpty ) )
 15101  256
             int alt110=2;
 15102  314
             switch ( input.LA(1) ) {
 15103  58
             case 209:
 15104  
                 {
 15105  112
                 alt110=1;
 15106  
                 }
 15107  112
                 break;
 15108  
             case 213:
 15109  
                 {
 15110  144
                 alt110=2;
 15111  
                 }
 15112  144
                 break;
 15113  
             default:
 15114  0
                 NoViableAltException nvae =
 15115  58
                     new NoViableAltException("", 110, 0, input);
 15116  58
 
 15117  0
                 throw nvae;
 15118  
 
 15119  
             }
 15120  
 
 15121  256
             switch (alt110) {
 15122  
                 case 1 :
 15123  3444
                     // com\\googlecode\\sparkleg\\Sparql.g:473:7: '(' ( graphNode )+ ')'
 15124  
                     {
 15125  112
                     char_literal330=(Token)match(input,209,FOLLOW_209_in_triplesNode3908);  
 15126  112
                     stream_209.add(char_literal330);
 15127  
 
 15128  
 
 15129  
                     // com\\googlecode\\sparkleg\\Sparql.g:473:11: ( graphNode )+
 15130  3556
                     int cnt109=0;
 15131  3444
                     loop109:
 15132  
                     do {
 15133  264
                         int alt109=2;
 15134  3708
                         switch ( input.LA(1) ) {
 15135  
                         case BLANK_NODE_LABEL:
 15136  3444
                         case DECIMAL:
 15137  
                         case DECIMAL_NEGATIVE:
 15138  3444
                         case DECIMAL_POSITIVE:
 15139  
                         case DOUBLE:
 15140  
                         case DOUBLE_NEGATIVE:
 15141  
                         case DOUBLE_POSITIVE:
 15142  
                         case FALSE:
 15143  
                         case INTEGER:
 15144  3444
                         case INTEGER_NEGATIVE:
 15145  3444
                         case INTEGER_POSITIVE:
 15146  
                         case IRI_REF:
 15147  
                         case PNAME_LN:
 15148  
                         case PNAME_NS:
 15149  
                         case STRING_LITERAL1:
 15150  
                         case STRING_LITERAL2:
 15151  
                         case STRING_LITERAL_LONG1:
 15152  
                         case STRING_LITERAL_LONG2:
 15153  
                         case TRUE:
 15154  
                         case VAR1:
 15155  
                         case VAR2:
 15156  
                         case 209:
 15157  
                         case 213:
 15158  
                             {
 15159  152
                             alt109=1;
 15160  
                             }
 15161  
                             break;
 15162  
 
 15163  
                         }
 15164  
 
 15165  264
                         switch (alt109) {
 15166  
                             case 1 :
 15167  
                                 // com\\googlecode\\sparkleg\\Sparql.g:473:11: graphNode
 15168  3356
                                 {
 15169  152
                                 pushFollow(FOLLOW_graphNode_in_triplesNode3910);
 15170  3508
                                 graphNode331=graphNode();
 15171  
 
 15172  152
                                 state._fsp--;
 15173  44
 
 15174  152
                                 stream_graphNode.add(graphNode331.getTree());
 15175  
 
 15176  24
                                 }
 15177  152
                                 break;
 15178  24
 
 15179  
                             default :
 15180  112
                                 if ( cnt109 >= 1 ) break loop109;
 15181  0
                                 EarlyExitException eee =
 15182  
                                     new EarlyExitException(109, input);
 15183  0
                                 throw eee;
 15184  
                         }
 15185  152
                         cnt109++;
 15186  152
                     } while (true);
 15187  
 
 15188  
 
 15189  132
                     char_literal332=(Token)match(input,210,FOLLOW_210_in_triplesNode3913);  
 15190  112
                     stream_210.add(char_literal332);
 15191  20
 
 15192  
 
 15193  
                     // AST REWRITE
 15194  
                     // elements: graphNode
 15195  
                     // token labels: 
 15196  
                     // rule labels: retval
 15197  
                     // token list labels: 
 15198  
                     // rule list labels: 
 15199  
                     // wildcard labels: 
 15200  112
                     retval.tree = root_0;
 15201  156
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15202  
 
 15203  112
                     root_0 = (Object)adaptor.nil();
 15204  16
                     // 473:26: -> ^( COLLECTION ( graphNode )+ )
 15205  
                     {
 15206  
                         // com\\googlecode\\sparkleg\\Sparql.g:473:29: ^( COLLECTION ( graphNode )+ )
 15207  4
                         {
 15208  112
                         Object root_1 = (Object)adaptor.nil();
 15209  116
                         root_1 = (Object)adaptor.becomeRoot(
 15210  
                         (Object)adaptor.create(COLLECTION, "COLLECTION")
 15211  
                         , root_1);
 15212  
 
 15213  112
                         if ( !(stream_graphNode.hasNext()) ) {
 15214  0
                             throw new RewriteEarlyExitException();
 15215  
                         }
 15216  264
                         while ( stream_graphNode.hasNext() ) {
 15217  152
                             adaptor.addChild(root_1, stream_graphNode.nextTree());
 15218  
 
 15219  
                         }
 15220  112
                         stream_graphNode.reset();
 15221  
 
 15222  112
                         adaptor.addChild(root_0, root_1);
 15223  
                         }
 15224  
 
 15225  
                     }
 15226  
 
 15227  
 
 15228  112
                     retval.tree = root_0;
 15229  
 
 15230  
                     }
 15231  112
                     break;
 15232  
                 case 2 :
 15233  
                     // com\\googlecode\\sparkleg\\Sparql.g:474:7: '[' propertyListNotEmpty ']'
 15234  12
                     {
 15235  144
                     char_literal333=(Token)match(input,213,FOLLOW_213_in_triplesNode3930);  
 15236  156
                     stream_213.add(char_literal333);
 15237  
 
 15238  
 
 15239  144
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode3932);
 15240  144
                     propertyListNotEmpty334=propertyListNotEmpty();
 15241  
 
 15242  144
                     state._fsp--;
 15243  
 
 15244  144
                     stream_propertyListNotEmpty.add(propertyListNotEmpty334.getTree());
 15245  
 
 15246  160
                     char_literal335=(Token)match(input,214,FOLLOW_214_in_triplesNode3934);  
 15247  144
                     stream_214.add(char_literal335);
 15248  28
 
 15249  
 
 15250  
                     // AST REWRITE
 15251  28
                     // elements: propertyListNotEmpty
 15252  
                     // token labels: 
 15253  
                     // rule labels: retval
 15254  
                     // token list labels: 
 15255  3416
                     // rule list labels: 
 15256  
                     // wildcard labels: 
 15257  144
                     retval.tree = root_0;
 15258  144
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15259  3384
 
 15260  144
                     root_0 = (Object)adaptor.nil();
 15261  
                     // 474:36: -> ^( TRIPLES_NODE propertyListNotEmpty )
 15262  3384
                     {
 15263  3384
                         // com\\googlecode\\sparkleg\\Sparql.g:474:39: ^( TRIPLES_NODE propertyListNotEmpty )
 15264  
                         {
 15265  3528
                         Object root_1 = (Object)adaptor.nil();
 15266  144
                         root_1 = (Object)adaptor.becomeRoot(
 15267  3384
                         (Object)adaptor.create(TRIPLES_NODE, "TRIPLES_NODE")
 15268  
                         , root_1);
 15269  
 
 15270  3528
                         adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 15271  
 
 15272  144
                         adaptor.addChild(root_0, root_1);
 15273  
                         }
 15274  32
 
 15275  
                     }
 15276  
 
 15277  32
 
 15278  176
                     retval.tree = root_0;
 15279  
 
 15280  32
                     }
 15281  
                     break;
 15282  32
 
 15283  
             }
 15284  256
             retval.stop = input.LT(-1);
 15285  
 
 15286  
 
 15287  256
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15288  3672
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15289  
 
 15290  
         }
 15291  3416
         catch (RecognitionException re) {
 15292  3416
             reportError(re);
 15293  0
             recover(input,re);
 15294  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15295  28
 
 15296  28
         }
 15297  28
 
 15298  28
         finally {
 15299  
                 // do for sure before leaving
 15300  256
         }
 15301  256
         return retval;
 15302  
     }
 15303  
     // $ANTLR end "triplesNode"
 15304  3444
 
 15305  3444
 
 15306  13620
     public static class graphNode_return extends ParserRuleReturnScope {
 15307  
         Object tree;
 15308  13620
         public Object getTree() { return tree; }
 15309  
     };
 15310  6510
 
 15311  
 
 15312  6510
     // $ANTLR start "graphNode"
 15313  
     // com\\googlecode\\sparkleg\\Sparql.g:477:1: graphNode : ( varOrTerm | triplesNode );
 15314  
     public final SparqlParser.graphNode_return graphNode() throws RecognitionException {
 15315  13620
         SparqlParser.graphNode_return retval = new SparqlParser.graphNode_return();
 15316  13620
         retval.start = input.LT(1);
 15317  
 
 15318  
 
 15319  20130
         Object root_0 = null;
 15320  6510
 
 15321  13620
         SparqlParser.varOrTerm_return varOrTerm336 =null;
 15322  
 
 15323  20130
         SparqlParser.triplesNode_return triplesNode337 =null;
 15324  
 
 15325  6510
 
 15326  
 
 15327  6510
         try {
 15328  
             // com\\googlecode\\sparkleg\\Sparql.g:478:5: ( varOrTerm | triplesNode )
 15329  13620
             int alt111=2;
 15330  13620
             switch ( input.LA(1) ) {
 15331  
             case BLANK_NODE_LABEL:
 15332  
             case DECIMAL:
 15333  6510
             case DECIMAL_NEGATIVE:
 15334  6510
             case DECIMAL_POSITIVE:
 15335  
             case DOUBLE:
 15336  
             case DOUBLE_NEGATIVE:
 15337  
             case DOUBLE_POSITIVE:
 15338  4932
             case FALSE:
 15339  
             case INTEGER:
 15340  4932
             case INTEGER_NEGATIVE:
 15341  
             case INTEGER_POSITIVE:
 15342  
             case IRI_REF:
 15343  
             case PNAME_LN:
 15344  
             case PNAME_NS:
 15345  
             case STRING_LITERAL1:
 15346  
             case STRING_LITERAL2:
 15347  
             case STRING_LITERAL_LONG1:
 15348  
             case STRING_LITERAL_LONG2:
 15349  
             case TRUE:
 15350  
             case VAR1:
 15351  
             case VAR2:
 15352  
                 {
 15353  13352
                 alt111=1;
 15354  
                 }
 15355  13352
                 break;
 15356  
             case 213:
 15357  
                 {
 15358  176
                 switch ( input.LA(2) ) {
 15359  
                 case 214:
 15360  
                     {
 15361  90
                     alt111=1;
 15362  
                     }
 15363  1668
                     break;
 15364  
                 case A:
 15365  1578
                 case INVERSE:
 15366  
                 case IRI_REF:
 15367  
                 case NEGATION:
 15368  
                 case PNAME_LN:
 15369  
                 case PNAME_NS:
 15370  
                 case VAR1:
 15371  
                 case VAR2:
 15372  
                 case 209:
 15373  
                     {
 15374  6596
                     alt111=2;
 15375  
                     }
 15376  86
                     break;
 15377  
                 default:
 15378  4932
                     NoViableAltException nvae =
 15379  
                         new NoViableAltException("", 111, 2, input);
 15380  
 
 15381  4932
                     throw nvae;
 15382  4932
 
 15383  
                 }
 15384  4932
 
 15385  
                 }
 15386  5108
                 break;
 15387  
             case 209:
 15388  
                 {
 15389  4996
                 switch ( input.LA(2) ) {
 15390  
                 case 210:
 15391  
                     {
 15392  16
                     alt111=1;
 15393  1578
                     }
 15394  16
                     break;
 15395  
                 case BLANK_NODE_LABEL:
 15396  1578
                 case DECIMAL:
 15397  1578
                 case DECIMAL_NEGATIVE:
 15398  
                 case DECIMAL_POSITIVE:
 15399  1578
                 case DOUBLE:
 15400  
                 case DOUBLE_NEGATIVE:
 15401  1578
                 case DOUBLE_POSITIVE:
 15402  
                 case FALSE:
 15403  
                 case INTEGER:
 15404  
                 case INTEGER_NEGATIVE:
 15405  
                 case INTEGER_POSITIVE:
 15406  
                 case IRI_REF:
 15407  6510
                 case PNAME_LN:
 15408  
                 case PNAME_NS:
 15409  
                 case STRING_LITERAL1:
 15410  6510
                 case STRING_LITERAL2:
 15411  6510
                 case STRING_LITERAL_LONG1:
 15412  
                 case STRING_LITERAL_LONG2:
 15413  
                 case TRUE:
 15414  
                 case VAR1:
 15415  
                 case VAR2:
 15416  
                 case 209:
 15417  
                 case 213:
 15418  
                     {
 15419  48
                     alt111=2;
 15420  
                     }
 15421  48
                     break;
 15422  
                 default:
 15423  6510
                     NoViableAltException nvae =
 15424  6510
                         new NoViableAltException("", 111, 3, input);
 15425  
 
 15426  0
                     throw nvae;
 15427  
 
 15428  
                 }
 15429  256
 
 15430  
                 }
 15431  298
                 break;
 15432  
             default:
 15433  28
                 NoViableAltException nvae =
 15434  
                     new NoViableAltException("", 111, 0, input);
 15435  
 
 15436  28
                 throw nvae;
 15437  
 
 15438  256
             }
 15439  256
 
 15440  13592
             switch (alt111) {
 15441  
                 case 1 :
 15442  256
                     // com\\googlecode\\sparkleg\\Sparql.g:478:7: varOrTerm
 15443  
                     {
 15444  13714
                     root_0 = (Object)adaptor.nil();
 15445  
 
 15446  256
 
 15447  13458
                     pushFollow(FOLLOW_varOrTerm_in_graphNode3959);
 15448  13458
                     varOrTerm336=varOrTerm();
 15449  
 
 15450  13458
                     state._fsp--;
 15451  
 
 15452  13714
                     adaptor.addChild(root_0, varOrTerm336.getTree());
 15453  256
 
 15454  
                     }
 15455  13458
                     break;
 15456  
                 case 2 :
 15457  146
                     // com\\googlecode\\sparkleg\\Sparql.g:478:19: triplesNode
 15458  
                     {
 15459  280
                     root_0 = (Object)adaptor.nil();
 15460  
 
 15461  
 
 15462  134
                     pushFollow(FOLLOW_triplesNode_in_graphNode3963);
 15463  134
                     triplesNode337=triplesNode();
 15464  108
 
 15465  134
                     state._fsp--;
 15466  108
 
 15467  134
                     adaptor.addChild(root_0, triplesNode337.getTree());
 15468  2
 
 15469  
                     }
 15470  
                     break;
 15471  2
 
 15472  
             }
 15473  13592
             retval.stop = input.LT(-1);
 15474  
 
 15475  254
 
 15476  13592
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15477  13592
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15478  
 
 15479  146
         }
 15480  28
         catch (RecognitionException re) {
 15481  28
             reportError(re);
 15482  174
             recover(input,re);
 15483  174
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15484  
 
 15485  146
         }
 15486  
 
 15487  146
         finally {
 15488  
                 // do for sure before leaving
 15489  13620
         }
 15490  13766
         return retval;
 15491  
     }
 15492  
     // $ANTLR end "graphNode"
 15493  
 
 15494  108
 
 15495  25800
     public static class varOrTerm_return extends ParserRuleReturnScope {
 15496  
         Object tree;
 15497  108
         public Object getTree() { return tree; }
 15498  108
     };
 15499  
 
 15500  108
 
 15501  
     // $ANTLR start "varOrTerm"
 15502  108
     // com\\googlecode\\sparkleg\\Sparql.g:481:1: varOrTerm : ( var | graphTerm );
 15503  
     public final SparqlParser.varOrTerm_return varOrTerm() throws RecognitionException {
 15504  25800
         SparqlParser.varOrTerm_return retval = new SparqlParser.varOrTerm_return();
 15505  25800
         retval.start = input.LT(1);
 15506  
 
 15507  
 
 15508  26054
         Object root_0 = null;
 15509  
 
 15510  25800
         SparqlParser.var_return var338 =null;
 15511  254
 
 15512  26054
         SparqlParser.graphTerm_return graphTerm339 =null;
 15513  
 
 15514  
 
 15515  2
 
 15516  2
         try {
 15517  2
             // com\\googlecode\\sparkleg\\Sparql.g:482:5: ( var | graphTerm )
 15518  25802
             int alt112=2;
 15519  25800
             switch ( input.LA(1) ) {
 15520  
             case VAR1:
 15521  
             case VAR2:
 15522  
                 {
 15523  19674
                 alt112=1;
 15524  256
                 }
 15525  19930
                 break;
 15526  
             case BLANK_NODE_LABEL:
 15527  
             case DECIMAL:
 15528  
             case DECIMAL_NEGATIVE:
 15529  
             case DECIMAL_POSITIVE:
 15530  8926
             case DOUBLE:
 15531  
             case DOUBLE_NEGATIVE:
 15532  8926
             case DOUBLE_POSITIVE:
 15533  
             case FALSE:
 15534  
             case INTEGER:
 15535  
             case INTEGER_NEGATIVE:
 15536  
             case INTEGER_POSITIVE:
 15537  
             case IRI_REF:
 15538  
             case PNAME_LN:
 15539  8926
             case PNAME_NS:
 15540  8926
             case STRING_LITERAL1:
 15541  
             case STRING_LITERAL2:
 15542  
             case STRING_LITERAL_LONG1:
 15543  8926
             case STRING_LITERAL_LONG2:
 15544  
             case TRUE:
 15545  8926
             case 209:
 15546  
             case 213:
 15547  8926
                 {
 15548  6126
                 alt112=2;
 15549  
                 }
 15550  6126
                 break;
 15551  
             default:
 15552  0
                 NoViableAltException nvae =
 15553  8926
                     new NoViableAltException("", 112, 0, input);
 15554  
 
 15555  0
                 throw nvae;
 15556  8926
 
 15557  
             }
 15558  8926
 
 15559  34726
             switch (alt112) {
 15560  8926
                 case 1 :
 15561  
                     // com\\googlecode\\sparkleg\\Sparql.g:482:7: var
 15562  
                     {
 15563  28600
                     root_0 = (Object)adaptor.nil();
 15564  
 
 15565  
 
 15566  19674
                     pushFollow(FOLLOW_var_in_varOrTerm3980);
 15567  19674
                     var338=var();
 15568  
 
 15569  19674
                     state._fsp--;
 15570  
 
 15571  19674
                     adaptor.addChild(root_0, var338.getTree());
 15572  
 
 15573  8926
                     }
 15574  19674
                     break;
 15575  
                 case 2 :
 15576  8926
                     // com\\googlecode\\sparkleg\\Sparql.g:483:7: graphTerm
 15577  8926
                     {
 15578  6126
                     root_0 = (Object)adaptor.nil();
 15579  
 
 15580  
 
 15581  6126
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm3988);
 15582  6126
                     graphTerm339=graphTerm();
 15583  
 
 15584  6126
                     state._fsp--;
 15585  
 
 15586  6126
                     adaptor.addChild(root_0, graphTerm339.getTree());
 15587  
 
 15588  
                     }
 15589  8926
                     break;
 15590  8926
 
 15591  
             }
 15592  25800
             retval.stop = input.LT(-1);
 15593  
 
 15594  
 
 15595  25800
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15596  25800
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15597  1578
 
 15598  
         }
 15599  0
         catch (RecognitionException re) {
 15600  0
             reportError(re);
 15601  0
             recover(input,re);
 15602  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15603  
 
 15604  1578
         }
 15605  1578
 
 15606  0
         finally {
 15607  
                 // do for sure before leaving
 15608  27378
         }
 15609  25800
         return retval;
 15610  1578
     }
 15611  
     // $ANTLR end "varOrTerm"
 15612  1578
 
 15613  
 
 15614  1012
     public static class varOrIRIref_return extends ParserRuleReturnScope {
 15615  
         Object tree;
 15616  1180
         public Object getTree() { return tree; }
 15617  
     };
 15618  1578
 
 15619  
 
 15620  1578
     // $ANTLR start "varOrIRIref"
 15621  
     // com\\googlecode\\sparkleg\\Sparql.g:486:1: varOrIRIref : ( var | iriRef );
 15622  
     public final SparqlParser.varOrIRIref_return varOrIRIref() throws RecognitionException {
 15623  1012
         SparqlParser.varOrIRIref_return retval = new SparqlParser.varOrIRIref_return();
 15624  1012
         retval.start = input.LT(1);
 15625  
 
 15626  1578
 
 15627  2590
         Object root_0 = null;
 15628  
 
 15629  1012
         SparqlParser.var_return var340 =null;
 15630  
 
 15631  1012
         SparqlParser.iriRef_return iriRef341 =null;
 15632  1104
 
 15633  
 
 15634  1104
 
 15635  
         try {
 15636  
             // com\\googlecode\\sparkleg\\Sparql.g:487:5: ( var | iriRef )
 15637  1012
             int alt113=2;
 15638  1012
             switch ( input.LA(1) ) {
 15639  
             case VAR1:
 15640  156
             case VAR2:
 15641  
                 {
 15642  734
                 alt113=1;
 15643  
                 }
 15644  578
                 break;
 15645  
             case IRI_REF:
 15646  
             case PNAME_LN:
 15647  
             case PNAME_NS:
 15648  
                 {
 15649  432
                 alt113=2;
 15650  
                 }
 15651  432
                 break;
 15652  
             default:
 15653  98
                 NoViableAltException nvae =
 15654  
                     new NoViableAltException("", 113, 0, input);
 15655  96
 
 15656  2
                 throw nvae;
 15657  
 
 15658  
             }
 15659  4
 
 15660  1010
             switch (alt113) {
 15661  4
                 case 1 :
 15662  
                     // com\\googlecode\\sparkleg\\Sparql.g:487:7: var
 15663  
                     {
 15664  578
                     root_0 = (Object)adaptor.nil();
 15665  204
 
 15666  
 
 15667  782
                     pushFollow(FOLLOW_var_in_varOrIRIref4005);
 15668  578
                     var340=var();
 15669  
 
 15670  592
                     state._fsp--;
 15671  
 
 15672  592
                     adaptor.addChild(root_0, var340.getTree());
 15673  
 
 15674  
                     }
 15675  578
                     break;
 15676  
                 case 2 :
 15677  
                     // com\\googlecode\\sparkleg\\Sparql.g:487:13: iriRef
 15678  
                     {
 15679  432
                     root_0 = (Object)adaptor.nil();
 15680  
 
 15681  1578
 
 15682  432
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref4009);
 15683  432
                     iriRef341=iriRef();
 15684  
 
 15685  1536
                     state._fsp--;
 15686  
 
 15687  432
                     adaptor.addChild(root_0, iriRef341.getTree());
 15688  1104
 
 15689  1104
                     }
 15690  
                     break;
 15691  1104
 
 15692  
             }
 15693  2114
             retval.stop = input.LT(-1);
 15694  
 
 15695  
 
 15696  2114
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15697  1010
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15698  
 
 15699  
         }
 15700  158
         catch (RecognitionException re) {
 15701  2
             reportError(re);
 15702  2
             recover(input,re);
 15703  158
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15704  156
 
 15705  
         }
 15706  156
 
 15707  0
         finally {
 15708  156
                 // do for sure before leaving
 15709  1012
         }
 15710  1012
         return retval;
 15711  156
     }
 15712  
     // $ANTLR end "varOrIRIref"
 15713  
 
 15714  
 
 15715  35602
     public static class var_return extends ParserRuleReturnScope {
 15716  
         Object tree;
 15717  35602
         public Object getTree() { return tree; }
 15718  96
     };
 15719  96
 
 15720  
 
 15721  96
     // $ANTLR start "var"
 15722  
     // com\\googlecode\\sparkleg\\Sparql.g:490:1: var : ( VAR1 | VAR2 );
 15723  96
     public final SparqlParser.var_return var() throws RecognitionException {
 15724  35602
         SparqlParser.var_return retval = new SparqlParser.var_return();
 15725  35602
         retval.start = input.LT(1);
 15726  96
 
 15727  
 
 15728  35602
         Object root_0 = null;
 15729  
 
 15730  35606
         Token set342=null;
 15731  
 
 15732  35602
         Object set342_tree=null;
 15733  4
 
 15734  4
         try {
 15735  
             // com\\googlecode\\sparkleg\\Sparql.g:491:5: ( VAR1 | VAR2 )
 15736  4
             // com\\googlecode\\sparkleg\\Sparql.g:
 15737  
             {
 15738  35606
             root_0 = (Object)adaptor.nil();
 15739  
 
 15740  
 
 15741  35606
             set342=(Token)input.LT(1);
 15742  
 
 15743  35602
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 15744  35602
                 input.consume();
 15745  35806
                 adaptor.addChild(root_0, 
 15746  
                 (Object)adaptor.create(set342)
 15747  
                 );
 15748  35806
                 state.errorRecovery=false;
 15749  204
             }
 15750  
             else {
 15751  204
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 15752  0
                 throw mse;
 15753  204
             }
 15754  
 
 15755  
 
 15756  204
             }
 15757  
 
 15758  35602
             retval.stop = input.LT(-1);
 15759  
 
 15760  14
 
 15761  35602
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15762  35602
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15763  14
 
 15764  14
         }
 15765  0
         catch (RecognitionException re) {
 15766  14
             reportError(re);
 15767  0
             recover(input,re);
 15768  14
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15769  
 
 15770  
         }
 15771  
 
 15772  0
         finally {
 15773  
                 // do for sure before leaving
 15774  37180
         }
 15775  35602
         return retval;
 15776  
     }
 15777  1578
     // $ANTLR end "var"
 15778  1578
 
 15779  
 
 15780  6126
     public static class graphTerm_return extends ParserRuleReturnScope {
 15781  
         Object tree;
 15782  6126
         public Object getTree() { return tree; }
 15783  
     };
 15784  
 
 15785  
 
 15786  
     // $ANTLR start "graphTerm"
 15787  
     // com\\googlecode\\sparkleg\\Sparql.g:494:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 15788  
     public final SparqlParser.graphTerm_return graphTerm() throws RecognitionException {
 15789  6126
         SparqlParser.graphTerm_return retval = new SparqlParser.graphTerm_return();
 15790  7704
         retval.start = input.LT(1);
 15791  1578
 
 15792  
 
 15793  6126
         Object root_0 = null;
 15794  
 
 15795  6126
         SparqlParser.iriRef_return iriRef343 =null;
 15796  30
 
 15797  6126
         SparqlParser.rdfLiteral_return rdfLiteral344 =null;
 15798  30
 
 15799  6126
         SparqlParser.numericLiteral_return numericLiteral345 =null;
 15800  
 
 15801  6126
         SparqlParser.booleanLiteral_return booleanLiteral346 =null;
 15802  
 
 15803  6126
         SparqlParser.blankNode_return blankNode347 =null;
 15804  
 
 15805  6156
         SparqlParser.nil_return nil348 =null;
 15806  30
 
 15807  
 
 15808  
 
 15809  30
         try {
 15810  
             // com\\googlecode\\sparkleg\\Sparql.g:495:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 15811  6156
             int alt114=6;
 15812  6156
             switch ( input.LA(1) ) {
 15813  
             case IRI_REF:
 15814  30
             case PNAME_LN:
 15815  30
             case PNAME_NS:
 15816  
                 {
 15817  4284
                 alt114=1;
 15818  
                 }
 15819  4284
                 break;
 15820  
             case STRING_LITERAL1:
 15821  30
             case STRING_LITERAL2:
 15822  
             case STRING_LITERAL_LONG1:
 15823  
             case STRING_LITERAL_LONG2:
 15824  30
                 {
 15825  654
                 alt114=2;
 15826  
                 }
 15827  624
                 break;
 15828  30
             case DECIMAL:
 15829  
             case DECIMAL_NEGATIVE:
 15830  
             case DECIMAL_POSITIVE:
 15831  30
             case DOUBLE:
 15832  30
             case DOUBLE_NEGATIVE:
 15833  
             case DOUBLE_POSITIVE:
 15834  
             case INTEGER:
 15835  30
             case INTEGER_NEGATIVE:
 15836  
             case INTEGER_POSITIVE:
 15837  
                 {
 15838  378
                 alt114=3;
 15839  
                 }
 15840  408
                 break;
 15841  
             case FALSE:
 15842  
             case TRUE:
 15843  30
                 {
 15844  46
                 alt114=4;
 15845  
                 }
 15846  16
                 break;
 15847  
             case BLANK_NODE_LABEL:
 15848  
             case 213:
 15849  
                 {
 15850  780
                 alt114=5;
 15851  
                 }
 15852  780
                 break;
 15853  
             case 209:
 15854  
                 {
 15855  44
                 alt114=6;
 15856  30
                 }
 15857  74
                 break;
 15858  
             default:
 15859  0
                 NoViableAltException nvae =
 15860  
                     new NoViableAltException("", 114, 0, input);
 15861  
 
 15862  0
                 throw nvae;
 15863  
 
 15864  1650
             }
 15865  
 
 15866  6126
             switch (alt114) {
 15867  
                 case 1 :
 15868  
                     // com\\googlecode\\sparkleg\\Sparql.g:495:7: iriRef
 15869  
                     {
 15870  4284
                     root_0 = (Object)adaptor.nil();
 15871  1650
 
 15872  1650
 
 15873  4284
                     pushFollow(FOLLOW_iriRef_in_graphTerm4047);
 15874  4284
                     iriRef343=iriRef();
 15875  1650
 
 15876  4284
                     state._fsp--;
 15877  1650
 
 15878  4284
                     adaptor.addChild(root_0, iriRef343.getTree());
 15879  
 
 15880  
                     }
 15881  4284
                     break;
 15882  
                 case 2 :
 15883  
                     // com\\googlecode\\sparkleg\\Sparql.g:496:7: rdfLiteral
 15884  
                     {
 15885  2274
                     root_0 = (Object)adaptor.nil();
 15886  
 
 15887  
 
 15888  2274
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm4055);
 15889  2274
                     rdfLiteral344=rdfLiteral();
 15890  
 
 15891  2274
                     state._fsp--;
 15892  
 
 15893  2274
                     adaptor.addChild(root_0, rdfLiteral344.getTree());
 15894  
 
 15895  
                     }
 15896  624
                     break;
 15897  1650
                 case 3 :
 15898  
                     // com\\googlecode\\sparkleg\\Sparql.g:497:7: numericLiteral
 15899  
                     {
 15900  2028
                     root_0 = (Object)adaptor.nil();
 15901  1650
 
 15902  
 
 15903  378
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm4063);
 15904  378
                     numericLiteral345=numericLiteral();
 15905  
 
 15906  378
                     state._fsp--;
 15907  
 
 15908  378
                     adaptor.addChild(root_0, numericLiteral345.getTree());
 15909  
 
 15910  
                     }
 15911  378
                     break;
 15912  
                 case 4 :
 15913  1650
                     // com\\googlecode\\sparkleg\\Sparql.g:498:7: booleanLiteral
 15914  1650
                     {
 15915  16
                     root_0 = (Object)adaptor.nil();
 15916  
 
 15917  
 
 15918  16
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm4071);
 15919  16
                     booleanLiteral346=booleanLiteral();
 15920  
 
 15921  16
                     state._fsp--;
 15922  
 
 15923  16
                     adaptor.addChild(root_0, booleanLiteral346.getTree());
 15924  
 
 15925  
                     }
 15926  16
                     break;
 15927  
                 case 5 :
 15928  1650
                     // com\\googlecode\\sparkleg\\Sparql.g:499:7: blankNode
 15929  1650
                     {
 15930  780
                     root_0 = (Object)adaptor.nil();
 15931  
 
 15932  1650
 
 15933  780
                     pushFollow(FOLLOW_blankNode_in_graphTerm4079);
 15934  2430
                     blankNode347=blankNode();
 15935  1650
 
 15936  780
                     state._fsp--;
 15937  1650
 
 15938  780
                     adaptor.addChild(root_0, blankNode347.getTree());
 15939  
 
 15940  1650
                     }
 15941  2430
                     break;
 15942  1650
                 case 6 :
 15943  
                     // com\\googlecode\\sparkleg\\Sparql.g:500:7: nil
 15944  
                     {
 15945  44
                     root_0 = (Object)adaptor.nil();
 15946  
 
 15947  
 
 15948  44
                     pushFollow(FOLLOW_nil_in_graphTerm4087);
 15949  44
                     nil348=nil();
 15950  1650
 
 15951  1694
                     state._fsp--;
 15952  
 
 15953  1694
                     adaptor.addChild(root_0, nil348.getTree());
 15954  
 
 15955  1650
                     }
 15956  
                     break;
 15957  
 
 15958  
             }
 15959  6126
             retval.stop = input.LT(-1);
 15960  
 
 15961  
 
 15962  6126
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15963  6126
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15964  1650
 
 15965  1650
         }
 15966  1650
         catch (RecognitionException re) {
 15967  0
             reportError(re);
 15968  1650
             recover(input,re);
 15969  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15970  
 
 15971  1650
         }
 15972  
 
 15973  0
         finally {
 15974  
                 // do for sure before leaving
 15975  6126
         }
 15976  7776
         return retval;
 15977  
     }
 15978  
     // $ANTLR end "graphTerm"
 15979  
 
 15980  
 
 15981  300
     public static class nil_return extends ParserRuleReturnScope {
 15982  
         Object tree;
 15983  300
         public Object getTree() { return tree; }
 15984  1698
     };
 15985  1698
 
 15986  
 
 15987  
     // $ANTLR start "nil"
 15988  48
     // com\\googlecode\\sparkleg\\Sparql.g:503:1: nil : '(' ')' -> NIL ;
 15989  
     public final SparqlParser.nil_return nil() throws RecognitionException {
 15990  300
         SparqlParser.nil_return retval = new SparqlParser.nil_return();
 15991  300
         retval.start = input.LT(1);
 15992  
 
 15993  
 
 15994  1998
         Object root_0 = null;
 15995  
 
 15996  300
         Token char_literal349=null;
 15997  300
         Token char_literal350=null;
 15998  48
 
 15999  348
         Object char_literal349_tree=null;
 16000  300
         Object char_literal350_tree=null;
 16001  300
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 16002  348
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 16003  48
 
 16004  
         try {
 16005  48
             // com\\googlecode\\sparkleg\\Sparql.g:504:5: ( '(' ')' -> NIL )
 16006  
             // com\\googlecode\\sparkleg\\Sparql.g:504:7: '(' ')'
 16007  48
             {
 16008  300
             char_literal349=(Token)match(input,209,FOLLOW_209_in_nil4108);  
 16009  300
             stream_209.add(char_literal349);
 16010  
 
 16011  
 
 16012  300
             char_literal350=(Token)match(input,210,FOLLOW_210_in_nil4110);  
 16013  300
             stream_210.add(char_literal350);
 16014  
 
 16015  
 
 16016  48
             // AST REWRITE
 16017  48
             // elements: 
 16018  48
             // token labels: 
 16019  
             // rule labels: retval
 16020  48
             // token list labels: 
 16021  
             // rule list labels: 
 16022  
             // wildcard labels: 
 16023  300
             retval.tree = root_0;
 16024  300
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16025  48
 
 16026  348
             root_0 = (Object)adaptor.nil();
 16027  
             // 504:15: -> NIL
 16028  
             {
 16029  300
                 adaptor.addChild(root_0, 
 16030  48
                 (Object)adaptor.create(NIL, "NIL")
 16031  
                 );
 16032  48
 
 16033  
             }
 16034  48
 
 16035  
 
 16036  300
             retval.tree = root_0;
 16037  
 
 16038  
             }
 16039  
 
 16040  348
             retval.stop = input.LT(-1);
 16041  
 
 16042  
 
 16043  348
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16044  300
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16045  
 
 16046  1650
         }
 16047  0
         catch (RecognitionException re) {
 16048  48
             reportError(re);
 16049  0
             recover(input,re);
 16050  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16051  
 
 16052  
         }
 16053  1650
 
 16054  0
         finally {
 16055  
                 // do for sure before leaving
 16056  1950
         }
 16057  1950
         return retval;
 16058  
     }
 16059  
     // $ANTLR end "nil"
 16060  
 
 16061  
 
 16062  6564
     public static class expression_return extends ParserRuleReturnScope {
 16063  
         Object tree;
 16064  6564
         public Object getTree() { return tree; }
 16065  
     };
 16066  
 
 16067  
 
 16068  
     // $ANTLR start "expression"
 16069  1650
     // com\\googlecode\\sparkleg\\Sparql.g:507:1: expression : conditionalOrExpression ;
 16070  1650
     public final SparqlParser.expression_return expression() throws RecognitionException {
 16071  6564
         SparqlParser.expression_return retval = new SparqlParser.expression_return();
 16072  6564
         retval.start = input.LT(1);
 16073  
 
 16074  
 
 16075  1698
         Object root_0 = null;
 16076  
 
 16077  1698
         SparqlParser.conditionalOrExpression_return conditionalOrExpression351 =null;
 16078  
 
 16079  
 
 16080  
 
 16081  
         try {
 16082  
             // com\\googlecode\\sparkleg\\Sparql.g:508:5: ( conditionalOrExpression )
 16083  
             // com\\googlecode\\sparkleg\\Sparql.g:508:7: conditionalOrExpression
 16084  1698
             {
 16085  8262
             root_0 = (Object)adaptor.nil();
 16086  
 
 16087  
 
 16088  8262
             pushFollow(FOLLOW_conditionalOrExpression_in_expression4131);
 16089  6564
             conditionalOrExpression351=conditionalOrExpression();
 16090  1698
 
 16091  8262
             state._fsp--;
 16092  
 
 16093  8262
             adaptor.addChild(root_0, conditionalOrExpression351.getTree());
 16094  
 
 16095  
             }
 16096  1698
 
 16097  8262
             retval.stop = input.LT(-1);
 16098  1698
 
 16099  
 
 16100  6564
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16101  6564
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16102  
 
 16103  
         }
 16104  0
         catch (RecognitionException re) {
 16105  0
             reportError(re);
 16106  1698
             recover(input,re);
 16107  1698
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16108  
 
 16109  1698
         }
 16110  
 
 16111  1698
         finally {
 16112  
                 // do for sure before leaving
 16113  6564
         }
 16114  6564
         return retval;
 16115  
     }
 16116  
     // $ANTLR end "expression"
 16117  
 
 16118  
 
 16119  6564
     public static class conditionalOrExpression_return extends ParserRuleReturnScope {
 16120  1698
         Object tree;
 16121  1698
         public Object getTree() { return tree; }
 16122  1698
     };
 16123  
 
 16124  1698
 
 16125  
     // $ANTLR start "conditionalOrExpression"
 16126  
     // com\\googlecode\\sparkleg\\Sparql.g:511:1: conditionalOrExpression : (c1= conditionalAndExpression -> $c1) ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )* ;
 16127  1698
     public final SparqlParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
 16128  6564
         SparqlParser.conditionalOrExpression_return retval = new SparqlParser.conditionalOrExpression_return();
 16129  6564
         retval.start = input.LT(1);
 16130  
 
 16131  
 
 16132  8262
         Object root_0 = null;
 16133  
 
 16134  6564
         Token string_literal352=null;
 16135  6564
         SparqlParser.conditionalAndExpression_return c1 =null;
 16136  
 
 16137  6564
         SparqlParser.conditionalAndExpression_return c2 =null;
 16138  
 
 16139  
 
 16140  8310
         Object string_literal352_tree=null;
 16141  8310
         RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
 16142  6564
         RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
 16143  
         try {
 16144  48
             // com\\googlecode\\sparkleg\\Sparql.g:512:5: ( (c1= conditionalAndExpression -> $c1) ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )* )
 16145  
             // com\\googlecode\\sparkleg\\Sparql.g:512:7: (c1= conditionalAndExpression -> $c1) ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )*
 16146  
             {
 16147  
             // com\\googlecode\\sparkleg\\Sparql.g:512:7: (c1= conditionalAndExpression -> $c1)
 16148  
             // com\\googlecode\\sparkleg\\Sparql.g:512:8: c1= conditionalAndExpression
 16149  
             {
 16150  8310
             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression4151);
 16151  6564
             c1=conditionalAndExpression();
 16152  
 
 16153  6564
             state._fsp--;
 16154  48
 
 16155  6612
             stream_conditionalAndExpression.add(c1.getTree());
 16156  
 
 16157  
             // AST REWRITE
 16158  48
             // elements: c1
 16159  48
             // token labels: 
 16160  
             // rule labels: retval, c1
 16161  48
             // token list labels: 
 16162  
             // rule list labels: 
 16163  48
             // wildcard labels: 
 16164  6564
             retval.tree = root_0;
 16165  6564
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16166  6564
             RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.tree:null);
 16167  
 
 16168  6564
             root_0 = (Object)adaptor.nil();
 16169  
             // 512:36: -> $c1
 16170  
             {
 16171  6564
                 adaptor.addChild(root_0, stream_c1.nextTree());
 16172  48
 
 16173  48
             }
 16174  48
 
 16175  
 
 16176  6612
             retval.tree = root_0;
 16177  
 
 16178  
             }
 16179  
 
 16180  
 
 16181  48
             // com\\googlecode\\sparkleg\\Sparql.g:512:44: ( '||' c2= conditionalAndExpression -> ^( '||' $conditionalOrExpression $c2) )*
 16182  48
             loop115:
 16183  
             do {
 16184  6756
                 int alt115=2;
 16185  6756
                 switch ( input.LA(1) ) {
 16186  48
                 case OR:
 16187  
                     {
 16188  240
                     alt115=1;
 16189  
                     }
 16190  48
                     break;
 16191  
 
 16192  
                 }
 16193  
 
 16194  6756
                 switch (alt115) {
 16195  
                     case 1 :
 16196  48
                         // com\\googlecode\\sparkleg\\Sparql.g:512:45: '||' c2= conditionalAndExpression
 16197  
                         {
 16198  192
                         string_literal352=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression4160);  
 16199  240
                         stream_OR.add(string_literal352);
 16200  
 
 16201  
 
 16202  1890
                         pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression4164);
 16203  192
                         c2=conditionalAndExpression();
 16204  48
 
 16205  192
                         state._fsp--;
 16206  
 
 16207  192
                         stream_conditionalAndExpression.add(c2.getTree());
 16208  
 
 16209  1698
                         // AST REWRITE
 16210  
                         // elements: c2, conditionalOrExpression, OR
 16211  
                         // token labels: 
 16212  1698
                         // rule labels: retval, c2
 16213  1698
                         // token list labels: 
 16214  
                         // rule list labels: 
 16215  
                         // wildcard labels: 
 16216  192
                         retval.tree = root_0;
 16217  192
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16218  192
                         RewriteRuleSubtreeStream stream_c2=new RewriteRuleSubtreeStream(adaptor,"rule c2",c2!=null?c2.tree:null);
 16219  
 
 16220  192
                         root_0 = (Object)adaptor.nil();
 16221  
                         // 512:78: -> ^( '||' $conditionalOrExpression $c2)
 16222  
                         {
 16223  
                             // com\\googlecode\\sparkleg\\Sparql.g:512:81: ^( '||' $conditionalOrExpression $c2)
 16224  
                             {
 16225  1890
                             Object root_1 = (Object)adaptor.nil();
 16226  1890
                             root_1 = (Object)adaptor.becomeRoot(
 16227  
                             stream_OR.nextNode()
 16228  
                             , root_1);
 16229  
 
 16230  192
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16231  1746
 
 16232  192
                             adaptor.addChild(root_1, stream_c2.nextTree());
 16233  1746
 
 16234  192
                             adaptor.addChild(root_0, root_1);
 16235  
                             }
 16236  
 
 16237  
                         }
 16238  
 
 16239  
 
 16240  1938
                         retval.tree = root_0;
 16241  1746
 
 16242  
                         }
 16243  192
                         break;
 16244  1746
 
 16245  
                     default :
 16246  8310
                         break loop115;
 16247  
                 }
 16248  192
             } while (true);
 16249  
 
 16250  
 
 16251  
             }
 16252  
 
 16253  6564
             retval.stop = input.LT(-1);
 16254  1746
 
 16255  
 
 16256  6564
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16257  8310
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16258  1746
 
 16259  
         }
 16260  1746
         catch (RecognitionException re) {
 16261  0
             reportError(re);
 16262  1746
             recover(input,re);
 16263  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16264  
 
 16265  
         }
 16266  1746
 
 16267  0
         finally {
 16268  
                 // do for sure before leaving
 16269  8310
         }
 16270  8310
         return retval;
 16271  
     }
 16272  
     // $ANTLR end "conditionalOrExpression"
 16273  
 
 16274  
 
 16275  6756
     public static class conditionalAndExpression_return extends ParserRuleReturnScope {
 16276  
         Object tree;
 16277  6756
         public Object getTree() { return tree; }
 16278  
     };
 16279  
 
 16280  
 
 16281  
     // $ANTLR start "conditionalAndExpression"
 16282  1746
     // com\\googlecode\\sparkleg\\Sparql.g:515:1: conditionalAndExpression : (v1= valueLogical -> $v1) ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )* ;
 16283  1746
     public final SparqlParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
 16284  6756
         SparqlParser.conditionalAndExpression_return retval = new SparqlParser.conditionalAndExpression_return();
 16285  6756
         retval.start = input.LT(1);
 16286  
 
 16287  
 
 16288  6756
         Object root_0 = null;
 16289  
 
 16290  6756
         Token string_literal353=null;
 16291  6756
         SparqlParser.valueLogical_return v1 =null;
 16292  
 
 16293  6756
         SparqlParser.valueLogical_return v2 =null;
 16294  
 
 16295  
 
 16296  6756
         Object string_literal353_tree=null;
 16297  8502
         RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
 16298  8502
         RewriteRuleSubtreeStream stream_valueLogical=new RewriteRuleSubtreeStream(adaptor,"rule valueLogical");
 16299  
         try {
 16300  
             // com\\googlecode\\sparkleg\\Sparql.g:516:5: ( (v1= valueLogical -> $v1) ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )* )
 16301  1746
             // com\\googlecode\\sparkleg\\Sparql.g:516:7: (v1= valueLogical -> $v1) ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )*
 16302  
             {
 16303  1746
             // com\\googlecode\\sparkleg\\Sparql.g:516:7: (v1= valueLogical -> $v1)
 16304  1746
             // com\\googlecode\\sparkleg\\Sparql.g:516:8: v1= valueLogical
 16305  1746
             {
 16306  8502
             pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression4198);
 16307  8502
             v1=valueLogical();
 16308  1746
 
 16309  8502
             state._fsp--;
 16310  1746
 
 16311  8502
             stream_valueLogical.add(v1.getTree());
 16312  1746
 
 16313  
             // AST REWRITE
 16314  1746
             // elements: v1
 16315  
             // token labels: 
 16316  1746
             // rule labels: v1, retval
 16317  
             // token list labels: 
 16318  1746
             // rule list labels: 
 16319  
             // wildcard labels: 
 16320  8502
             retval.tree = root_0;
 16321  6756
             RewriteRuleSubtreeStream stream_v1=new RewriteRuleSubtreeStream(adaptor,"rule v1",v1!=null?v1.tree:null);
 16322  8502
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16323  
 
 16324  8502
             root_0 = (Object)adaptor.nil();
 16325  
             // 516:24: -> $v1
 16326  1746
             {
 16327  6756
                 adaptor.addChild(root_0, stream_v1.nextTree());
 16328  1746
 
 16329  
             }
 16330  
 
 16331  1746
 
 16332  8502
             retval.tree = root_0;
 16333  1746
 
 16334  1746
             }
 16335  1746
 
 16336  1746
 
 16337  1746
             // com\\googlecode\\sparkleg\\Sparql.g:516:32: ( '&&' v2= valueLogical -> ^( '&&' $conditionalAndExpression $v2) )*
 16338  1746
             loop116:
 16339  1746
             do {
 16340  8694
                 int alt116=2;
 16341  8694
                 switch ( input.LA(1) ) {
 16342  1746
                 case AND:
 16343  1746
                     {
 16344  1938
                     alt116=1;
 16345  1746
                     }
 16346  1746
                     break;
 16347  1746
 
 16348  1746
                 }
 16349  1746
 
 16350  6948
                 switch (alt116) {
 16351  
                     case 1 :
 16352  
                         // com\\googlecode\\sparkleg\\Sparql.g:516:33: '&&' v2= valueLogical
 16353  
                         {
 16354  192
                         string_literal353=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression4207);  
 16355  192
                         stream_AND.add(string_literal353);
 16356  
 
 16357  1746
 
 16358  1938
                         pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression4211);
 16359  192
                         v2=valueLogical();
 16360  1746
 
 16361  192
                         state._fsp--;
 16362  1746
 
 16363  192
                         stream_valueLogical.add(v2.getTree());
 16364  
 
 16365  
                         // AST REWRITE
 16366  
                         // elements: v2, conditionalAndExpression, AND
 16367  
                         // token labels: 
 16368  
                         // rule labels: retval, v2
 16369  
                         // token list labels: 
 16370  
                         // rule list labels: 
 16371  1746
                         // wildcard labels: 
 16372  1938
                         retval.tree = root_0;
 16373  1938
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16374  192
                         RewriteRuleSubtreeStream stream_v2=new RewriteRuleSubtreeStream(adaptor,"rule v2",v2!=null?v2.tree:null);
 16375  1746
 
 16376  192
                         root_0 = (Object)adaptor.nil();
 16377  
                         // 516:54: -> ^( '&&' $conditionalAndExpression $v2)
 16378  1746
                         {
 16379  
                             // com\\googlecode\\sparkleg\\Sparql.g:516:57: ^( '&&' $conditionalAndExpression $v2)
 16380  
                             {
 16381  192
                             Object root_1 = (Object)adaptor.nil();
 16382  192
                             root_1 = (Object)adaptor.becomeRoot(
 16383  1746
                             stream_AND.nextNode()
 16384  
                             , root_1);
 16385  
 
 16386  192
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16387  
 
 16388  192
                             adaptor.addChild(root_1, stream_v2.nextTree());
 16389  1746
 
 16390  1938
                             adaptor.addChild(root_0, root_1);
 16391  
                             }
 16392  
 
 16393  274
                         }
 16394  
 
 16395  274
 
 16396  192
                         retval.tree = root_0;
 16397  
 
 16398  56
                         }
 16399  192
                         break;
 16400  56
 
 16401  
                     default :
 16402  6756
                         break loop116;
 16403  36
                 }
 16404  192
             } while (true);
 16405  36
 
 16406  
 
 16407  
             }
 16408  36
 
 16409  6756
             retval.stop = input.LT(-1);
 16410  36
 
 16411  
 
 16412  6756
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16413  6760
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16414  
 
 16415  4
         }
 16416  0
         catch (RecognitionException re) {
 16417  0
             reportError(re);
 16418  6
             recover(input,re);
 16419  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16420  6
 
 16421  
         }
 16422  
 
 16423  4
         finally {
 16424  
                 // do for sure before leaving
 16425  6760
         }
 16426  6756
         return retval;
 16427  
     }
 16428  4
     // $ANTLR end "conditionalAndExpression"
 16429  
 
 16430  
 
 16431  6948
     public static class valueLogical_return extends ParserRuleReturnScope {
 16432  
         Object tree;
 16433  1746
         public Object getTree() { return tree; }
 16434  
     };
 16435  
 
 16436  
 
 16437  
     // $ANTLR start "valueLogical"
 16438  
     // com\\googlecode\\sparkleg\\Sparql.g:519:1: valueLogical : relationalExpression ;
 16439  
     public final SparqlParser.valueLogical_return valueLogical() throws RecognitionException {
 16440  7222
         SparqlParser.valueLogical_return retval = new SparqlParser.valueLogical_return();
 16441  7222
         retval.start = input.LT(1);
 16442  
 
 16443  
 
 16444  7222
         Object root_0 = null;
 16445  274
 
 16446  6948
         SparqlParser.relationalExpression_return relationalExpression354 =null;
 16447  274
 
 16448  
 
 16449  274
 
 16450  
         try {
 16451  
             // com\\googlecode\\sparkleg\\Sparql.g:520:5: ( relationalExpression )
 16452  
             // com\\googlecode\\sparkleg\\Sparql.g:520:7: relationalExpression
 16453  
             {
 16454  6948
             root_0 = (Object)adaptor.nil();
 16455  
 
 16456  
 
 16457  6948
             pushFollow(FOLLOW_relationalExpression_in_valueLogical4242);
 16458  7222
             relationalExpression354=relationalExpression();
 16459  274
 
 16460  7222
             state._fsp--;
 16461  
 
 16462  7222
             adaptor.addChild(root_0, relationalExpression354.getTree());
 16463  
 
 16464  
             }
 16465  
 
 16466  6948
             retval.stop = input.LT(-1);
 16467  274
 
 16468  274
 
 16469  6948
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16470  6948
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16471  
 
 16472  274
         }
 16473  0
         catch (RecognitionException re) {
 16474  274
             reportError(re);
 16475  0
             recover(input,re);
 16476  274
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16477  
 
 16478  
         }
 16479  
 
 16480  0
         finally {
 16481  
                 // do for sure before leaving
 16482  7222
         }
 16483  6948
         return retval;
 16484  
     }
 16485  
     // $ANTLR end "valueLogical"
 16486  
 
 16487  
 
 16488  274
     public static class relationalExpression_return extends ParserRuleReturnScope {
 16489  
         Object tree;
 16490  6948
         public Object getTree() { return tree; }
 16491  
     };
 16492  
 
 16493  
 
 16494  
     // $ANTLR start "relationalExpression"
 16495  56
     // com\\googlecode\\sparkleg\\Sparql.g:523:1: relationalExpression : (n1= numericExpression -> $n1) ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? ;
 16496  56
     public final SparqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
 16497  6948
         SparqlParser.relationalExpression_return retval = new SparqlParser.relationalExpression_return();
 16498  6948
         retval.start = input.LT(1);
 16499  56
 
 16500  56
 
 16501  6948
         Object root_0 = null;
 16502  56
 
 16503  6948
         Token char_literal355=null;
 16504  7004
         Token string_literal356=null;
 16505  6948
         Token char_literal357=null;
 16506  6948
         Token char_literal358=null;
 16507  6948
         Token string_literal359=null;
 16508  6948
         Token string_literal360=null;
 16509  6948
         Token IN361=null;
 16510  6948
         Token NOT362=null;
 16511  6948
         Token IN363=null;
 16512  6948
         SparqlParser.numericExpression_return n1 =null;
 16513  56
 
 16514  7004
         SparqlParser.numericExpression_return n2 =null;
 16515  56
 
 16516  6948
         SparqlParser.numericExpression_return n3 =null;
 16517  56
 
 16518  6948
         SparqlParser.numericExpression_return n4 =null;
 16519  
 
 16520  6948
         SparqlParser.numericExpression_return n5 =null;
 16521  
 
 16522  7004
         SparqlParser.numericExpression_return n6 =null;
 16523  56
 
 16524  6948
         SparqlParser.numericExpression_return n7 =null;
 16525  
 
 16526  6948
         SparqlParser.expressionList_return l2 =null;
 16527  56
 
 16528  6948
         SparqlParser.expressionList_return l3 =null;
 16529  56
 
 16530  
 
 16531  7004
         Object char_literal355_tree=null;
 16532  6948
         Object string_literal356_tree=null;
 16533  6948
         Object char_literal357_tree=null;
 16534  6948
         Object char_literal358_tree=null;
 16535  6948
         Object string_literal359_tree=null;
 16536  6948
         Object string_literal360_tree=null;
 16537  7004
         Object IN361_tree=null;
 16538  6948
         Object NOT362_tree=null;
 16539  6948
         Object IN363_tree=null;
 16540  6948
         RewriteRuleTokenStream stream_GREATER=new RewriteRuleTokenStream(adaptor,"token GREATER");
 16541  6948
         RewriteRuleTokenStream stream_LESS_EQUAL=new RewriteRuleTokenStream(adaptor,"token LESS_EQUAL");
 16542  6948
         RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
 16543  7004
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 16544  6948
         RewriteRuleTokenStream stream_NOT_EQUAL=new RewriteRuleTokenStream(adaptor,"token NOT_EQUAL");
 16545  6948
         RewriteRuleTokenStream stream_GREATER_EQUAL=new RewriteRuleTokenStream(adaptor,"token GREATER_EQUAL");
 16546  6948
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 16547  6948
         RewriteRuleTokenStream stream_LESS=new RewriteRuleTokenStream(adaptor,"token LESS");
 16548  6948
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 16549  6948
         RewriteRuleSubtreeStream stream_numericExpression=new RewriteRuleSubtreeStream(adaptor,"rule numericExpression");
 16550  36
         try {
 16551  36
             // com\\googlecode\\sparkleg\\Sparql.g:524:5: ( (n1= numericExpression -> $n1) ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? )
 16552  
             // com\\googlecode\\sparkleg\\Sparql.g:524:7: (n1= numericExpression -> $n1) ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16553  
             {
 16554  36
             // com\\googlecode\\sparkleg\\Sparql.g:524:7: (n1= numericExpression -> $n1)
 16555  36
             // com\\googlecode\\sparkleg\\Sparql.g:524:8: n1= numericExpression
 16556  
             {
 16557  6984
             pushFollow(FOLLOW_numericExpression_in_relationalExpression4262);
 16558  6948
             n1=numericExpression();
 16559  36
 
 16560  6948
             state._fsp--;
 16561  
 
 16562  6948
             stream_numericExpression.add(n1.getTree());
 16563  
 
 16564  
             // AST REWRITE
 16565  
             // elements: n1
 16566  
             // token labels: 
 16567  
             // rule labels: n1, retval
 16568  36
             // token list labels: 
 16569  36
             // rule list labels: 
 16570  36
             // wildcard labels: 
 16571  6948
             retval.tree = root_0;
 16572  6984
             RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16573  6948
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16574  
 
 16575  6948
             root_0 = (Object)adaptor.nil();
 16576  
             // 524:29: -> $n1
 16577  36
             {
 16578  6984
                 adaptor.addChild(root_0, stream_n1.nextTree());
 16579  
 
 16580  
             }
 16581  
 
 16582  36
 
 16583  6948
             retval.tree = root_0;
 16584  36
 
 16585  
             }
 16586  36
 
 16587  
 
 16588  
             // com\\googlecode\\sparkleg\\Sparql.g:524:37: ( ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) ) | ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) ) | ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) ) | ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) ) | ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) ) | ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16589  6948
             int alt117=9;
 16590  6948
             switch ( input.LA(1) ) {
 16591  
                 case EQUAL:
 16592  36
                     {
 16593  1096
                     alt117=1;
 16594  
                     }
 16595  1096
                     break;
 16596  
                 case NOT_EQUAL:
 16597  
                     {
 16598  260
                     alt117=2;
 16599  
                     }
 16600  224
                     break;
 16601  
                 case LESS:
 16602  
                     {
 16603  144
                     alt117=3;
 16604  
                     }
 16605  180
                     break;
 16606  36
                 case GREATER:
 16607  
                     {
 16608  144
                     alt117=4;
 16609  36
                     }
 16610  180
                     break;
 16611  
                 case LESS_EQUAL:
 16612  36
                     {
 16613  16
                     alt117=5;
 16614  36
                     }
 16615  16
                     break;
 16616  
                 case GREATER_EQUAL:
 16617  
                     {
 16618  24
                     alt117=6;
 16619  
                     }
 16620  24
                     break;
 16621  
                 case IN:
 16622  
                     {
 16623  52
                     alt117=7;
 16624  36
                     }
 16625  52
                     break;
 16626  
                 case NOT:
 16627  36
                     {
 16628  16
                     alt117=8;
 16629  
                     }
 16630  
                     break;
 16631  
             }
 16632  36
 
 16633  6984
             switch (alt117) {
 16634  
                 case 1 :
 16635  
                     // com\\googlecode\\sparkleg\\Sparql.g:524:38: ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) )
 16636  
                     {
 16637  36
                     // com\\googlecode\\sparkleg\\Sparql.g:524:38: ( '=' n2= numericExpression -> ^( '=' $relationalExpression $n2) )
 16638  
                     // com\\googlecode\\sparkleg\\Sparql.g:524:39: '=' n2= numericExpression
 16639  36
                     {
 16640  1096
                     char_literal355=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_relationalExpression4272);  
 16641  1132
                     stream_EQUAL.add(char_literal355);
 16642  
 
 16643  
 
 16644  1096
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4276);
 16645  1096
                     n2=numericExpression();
 16646  
 
 16647  1132
                     state._fsp--;
 16648  
 
 16649  1096
                     stream_numericExpression.add(n2.getTree());
 16650  
 
 16651  
                     // AST REWRITE
 16652  
                     // elements: relationalExpression, EQUAL, n2
 16653  36
                     // token labels: 
 16654  
                     // rule labels: retval, n2
 16655  
                     // token list labels: 
 16656  
                     // rule list labels: 
 16657  
                     // wildcard labels: 
 16658  1096
                     retval.tree = root_0;
 16659  1096
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16660  1100
                     RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 16661  4
 
 16662  1096
                     root_0 = (Object)adaptor.nil();
 16663  
                     // 524:64: -> ^( '=' $relationalExpression $n2)
 16664  4
                     {
 16665  4
                         // com\\googlecode\\sparkleg\\Sparql.g:524:67: ^( '=' $relationalExpression $n2)
 16666  
                         {
 16667  1100
                         Object root_1 = (Object)adaptor.nil();
 16668  1096
                         root_1 = (Object)adaptor.becomeRoot(
 16669  4
                         stream_EQUAL.nextNode()
 16670  
                         , root_1);
 16671  
 
 16672  1096
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16673  
 
 16674  1096
                         adaptor.addChild(root_1, stream_n2.nextTree());
 16675  
 
 16676  1096
                         adaptor.addChild(root_0, root_1);
 16677  
                         }
 16678  4
 
 16679  4
                     }
 16680  4
 
 16681  
 
 16682  1100
                     retval.tree = root_0;
 16683  
 
 16684  
                     }
 16685  
 
 16686  
 
 16687  4
                     }
 16688  1100
                     break;
 16689  
                 case 2 :
 16690  
                     // com\\googlecode\\sparkleg\\Sparql.g:525:39: ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) )
 16691  
                     {
 16692  4
                     // com\\googlecode\\sparkleg\\Sparql.g:525:39: ( '!=' n3= numericExpression -> ^( '!=' $relationalExpression $n3) )
 16693  
                     // com\\googlecode\\sparkleg\\Sparql.g:525:40: '!=' n3= numericExpression
 16694  4
                     {
 16695  224
                     string_literal356=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_relationalExpression4333);  
 16696  228
                     stream_NOT_EQUAL.add(string_literal356);
 16697  
 
 16698  
 
 16699  224
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4337);
 16700  224
                     n3=numericExpression();
 16701  
 
 16702  228
                     state._fsp--;
 16703  
 
 16704  224
                     stream_numericExpression.add(n3.getTree());
 16705  
 
 16706  
                     // AST REWRITE
 16707  
                     // elements: NOT_EQUAL, relationalExpression, n3
 16708  4
                     // token labels: 
 16709  
                     // rule labels: retval, n3
 16710  
                     // token list labels: 
 16711  
                     // rule list labels: 
 16712  
                     // wildcard labels: 
 16713  224
                     retval.tree = root_0;
 16714  224
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16715  230
                     RewriteRuleSubtreeStream stream_n3=new RewriteRuleSubtreeStream(adaptor,"rule n3",n3!=null?n3.tree:null);
 16716  6
 
 16717  224
                     root_0 = (Object)adaptor.nil();
 16718  
                     // 525:66: -> ^( '!=' $relationalExpression $n3)
 16719  6
                     {
 16720  6
                         // com\\googlecode\\sparkleg\\Sparql.g:525:69: ^( '!=' $relationalExpression $n3)
 16721  
                         {
 16722  230
                         Object root_1 = (Object)adaptor.nil();
 16723  224
                         root_1 = (Object)adaptor.becomeRoot(
 16724  6
                         stream_NOT_EQUAL.nextNode()
 16725  
                         , root_1);
 16726  
 
 16727  224
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16728  
 
 16729  224
                         adaptor.addChild(root_1, stream_n3.nextTree());
 16730  
 
 16731  224
                         adaptor.addChild(root_0, root_1);
 16732  
                         }
 16733  6
 
 16734  6
                     }
 16735  6
 
 16736  
 
 16737  230
                     retval.tree = root_0;
 16738  
 
 16739  
                     }
 16740  
 
 16741  
 
 16742  6
                     }
 16743  230
                     break;
 16744  
                 case 3 :
 16745  
                     // com\\googlecode\\sparkleg\\Sparql.g:526:39: ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) )
 16746  
                     {
 16747  6
                     // com\\googlecode\\sparkleg\\Sparql.g:526:39: ( '<' n4= numericExpression -> ^( '<' $relationalExpression $n4) )
 16748  
                     // com\\googlecode\\sparkleg\\Sparql.g:526:40: '<' n4= numericExpression
 16749  6
                     {
 16750  144
                     char_literal357=(Token)match(input,LESS,FOLLOW_LESS_in_relationalExpression4392);  
 16751  150
                     stream_LESS.add(char_literal357);
 16752  
 
 16753  
 
 16754  144
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4396);
 16755  144
                     n4=numericExpression();
 16756  
 
 16757  150
                     state._fsp--;
 16758  
 
 16759  144
                     stream_numericExpression.add(n4.getTree());
 16760  
 
 16761  
                     // AST REWRITE
 16762  
                     // elements: relationalExpression, LESS, n4
 16763  6
                     // token labels: 
 16764  
                     // rule labels: retval, n4
 16765  
                     // token list labels: 
 16766  
                     // rule list labels: 
 16767  
                     // wildcard labels: 
 16768  144
                     retval.tree = root_0;
 16769  144
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16770  148
                     RewriteRuleSubtreeStream stream_n4=new RewriteRuleSubtreeStream(adaptor,"rule n4",n4!=null?n4.tree:null);
 16771  4
 
 16772  144
                     root_0 = (Object)adaptor.nil();
 16773  
                     // 526:65: -> ^( '<' $relationalExpression $n4)
 16774  4
                     {
 16775  4
                         // com\\googlecode\\sparkleg\\Sparql.g:526:68: ^( '<' $relationalExpression $n4)
 16776  
                         {
 16777  148
                         Object root_1 = (Object)adaptor.nil();
 16778  144
                         root_1 = (Object)adaptor.becomeRoot(
 16779  4
                         stream_LESS.nextNode()
 16780  
                         , root_1);
 16781  
 
 16782  144
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16783  
 
 16784  144
                         adaptor.addChild(root_1, stream_n4.nextTree());
 16785  
 
 16786  144
                         adaptor.addChild(root_0, root_1);
 16787  
                         }
 16788  4
 
 16789  4
                     }
 16790  4
 
 16791  
 
 16792  148
                     retval.tree = root_0;
 16793  
 
 16794  
                     }
 16795  
 
 16796  
 
 16797  4
                     }
 16798  148
                     break;
 16799  
                 case 4 :
 16800  
                     // com\\googlecode\\sparkleg\\Sparql.g:527:39: ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) )
 16801  
                     {
 16802  4
                     // com\\googlecode\\sparkleg\\Sparql.g:527:39: ( '>' n5= numericExpression -> ^( '>' $relationalExpression $n5) )
 16803  
                     // com\\googlecode\\sparkleg\\Sparql.g:527:40: '>' n5= numericExpression
 16804  4
                     {
 16805  144
                     char_literal358=(Token)match(input,GREATER,FOLLOW_GREATER_in_relationalExpression4451);  
 16806  148
                     stream_GREATER.add(char_literal358);
 16807  
 
 16808  
 
 16809  144
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4455);
 16810  144
                     n5=numericExpression();
 16811  
 
 16812  148
                     state._fsp--;
 16813  
 
 16814  144
                     stream_numericExpression.add(n5.getTree());
 16815  
 
 16816  
                     // AST REWRITE
 16817  
                     // elements: relationalExpression, GREATER, n5
 16818  4
                     // token labels: 
 16819  
                     // rule labels: retval, n5
 16820  
                     // token list labels: 
 16821  
                     // rule list labels: 
 16822  
                     // wildcard labels: 
 16823  144
                     retval.tree = root_0;
 16824  144
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16825  148
                     RewriteRuleSubtreeStream stream_n5=new RewriteRuleSubtreeStream(adaptor,"rule n5",n5!=null?n5.tree:null);
 16826  4
 
 16827  144
                     root_0 = (Object)adaptor.nil();
 16828  
                     // 527:65: -> ^( '>' $relationalExpression $n5)
 16829  4
                     {
 16830  4
                         // com\\googlecode\\sparkleg\\Sparql.g:527:68: ^( '>' $relationalExpression $n5)
 16831  
                         {
 16832  144
                         Object root_1 = (Object)adaptor.nil();
 16833  148
                         root_1 = (Object)adaptor.becomeRoot(
 16834  4
                         stream_GREATER.nextNode()
 16835  
                         , root_1);
 16836  4
 
 16837  144
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16838  4
 
 16839  144
                         adaptor.addChild(root_1, stream_n5.nextTree());
 16840  
 
 16841  144
                         adaptor.addChild(root_0, root_1);
 16842  
                         }
 16843  
 
 16844  
                     }
 16845  
 
 16846  
 
 16847  148
                     retval.tree = root_0;
 16848  4
 
 16849  4
                     }
 16850  
 
 16851  4
 
 16852  
                     }
 16853  144
                     break;
 16854  
                 case 5 :
 16855  
                     // com\\googlecode\\sparkleg\\Sparql.g:528:39: ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) )
 16856  4
                     {
 16857  4
                     // com\\googlecode\\sparkleg\\Sparql.g:528:39: ( '<=' n6= numericExpression -> ^( '<=' $relationalExpression $n6) )
 16858  
                     // com\\googlecode\\sparkleg\\Sparql.g:528:40: '<=' n6= numericExpression
 16859  
                     {
 16860  16
                     string_literal359=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_relationalExpression4509);  
 16861  20
                     stream_LESS_EQUAL.add(string_literal359);
 16862  
 
 16863  
 
 16864  16
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4513);
 16865  20
                     n6=numericExpression();
 16866  
 
 16867  20
                     state._fsp--;
 16868  
 
 16869  20
                     stream_numericExpression.add(n6.getTree());
 16870  
 
 16871  
                     // AST REWRITE
 16872  
                     // elements: LESS_EQUAL, n6, relationalExpression
 16873  
                     // token labels: 
 16874  
                     // rule labels: retval, n6
 16875  4
                     // token list labels: 
 16876  
                     // rule list labels: 
 16877  
                     // wildcard labels: 
 16878  16
                     retval.tree = root_0;
 16879  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16880  16
                     RewriteRuleSubtreeStream stream_n6=new RewriteRuleSubtreeStream(adaptor,"rule n6",n6!=null?n6.tree:null);
 16881  
 
 16882  16
                     root_0 = (Object)adaptor.nil();
 16883  
                     // 528:66: -> ^( '<=' $relationalExpression $n6)
 16884  
                     {
 16885  
                         // com\\googlecode\\sparkleg\\Sparql.g:528:69: ^( '<=' $relationalExpression $n6)
 16886  
                         {
 16887  16
                         Object root_1 = (Object)adaptor.nil();
 16888  1762
                         root_1 = (Object)adaptor.becomeRoot(
 16889  
                         stream_LESS_EQUAL.nextNode()
 16890  
                         , root_1);
 16891  1746
 
 16892  1762
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16893  
 
 16894  16
                         adaptor.addChild(root_1, stream_n6.nextTree());
 16895  
 
 16896  16
                         adaptor.addChild(root_0, root_1);
 16897  
                         }
 16898  
 
 16899  
                     }
 16900  
 
 16901  
 
 16902  16
                     retval.tree = root_0;
 16903  
 
 16904  1746
                     }
 16905  1746
 
 16906  
 
 16907  
                     }
 16908  16
                     break;
 16909  
                 case 6 :
 16910  2158
                     // com\\googlecode\\sparkleg\\Sparql.g:529:39: ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) )
 16911  
                     {
 16912  2158
                     // com\\googlecode\\sparkleg\\Sparql.g:529:39: ( '>=' n7= numericExpression -> ^( '>=' $relationalExpression $n7) )
 16913  
                     // com\\googlecode\\sparkleg\\Sparql.g:529:40: '>=' n7= numericExpression
 16914  
                     {
 16915  24
                     string_literal360=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_relationalExpression4567);  
 16916  24
                     stream_GREATER_EQUAL.add(string_literal360);
 16917  
 
 16918  
 
 16919  2182
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4571);
 16920  2182
                     n7=numericExpression();
 16921  
 
 16922  24
                     state._fsp--;
 16923  2158
 
 16924  24
                     stream_numericExpression.add(n7.getTree());
 16925  2158
 
 16926  
                     // AST REWRITE
 16927  
                     // elements: GREATER_EQUAL, n7, relationalExpression
 16928  
                     // token labels: 
 16929  
                     // rule labels: retval, n7
 16930  
                     // token list labels: 
 16931  
                     // rule list labels: 
 16932  
                     // wildcard labels: 
 16933  2182
                     retval.tree = root_0;
 16934  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16935  24
                     RewriteRuleSubtreeStream stream_n7=new RewriteRuleSubtreeStream(adaptor,"rule n7",n7!=null?n7.tree:null);
 16936  2158
 
 16937  2182
                     root_0 = (Object)adaptor.nil();
 16938  
                     // 529:66: -> ^( '>=' $relationalExpression $n7)
 16939  2158
                     {
 16940  
                         // com\\googlecode\\sparkleg\\Sparql.g:529:69: ^( '>=' $relationalExpression $n7)
 16941  2158
                         {
 16942  24
                         Object root_1 = (Object)adaptor.nil();
 16943  24
                         root_1 = (Object)adaptor.becomeRoot(
 16944  
                         stream_GREATER_EQUAL.nextNode()
 16945  2158
                         , root_1);
 16946  
 
 16947  24
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16948  2158
 
 16949  2182
                         adaptor.addChild(root_1, stream_n7.nextTree());
 16950  
 
 16951  24
                         adaptor.addChild(root_0, root_1);
 16952  
                         }
 16953  
 
 16954  
                     }
 16955  
 
 16956  
 
 16957  24
                     retval.tree = root_0;
 16958  
 
 16959  
                     }
 16960  
 
 16961  2158
 
 16962  2158
                     }
 16963  24
                     break;
 16964  
                 case 7 :
 16965  
                     // com\\googlecode\\sparkleg\\Sparql.g:530:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16966  
                     {
 16967  2158
                     // com\\googlecode\\sparkleg\\Sparql.g:530:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16968  
                     // com\\googlecode\\sparkleg\\Sparql.g:530:40: IN l2= expressionList
 16969  2158
                     {
 16970  16
                     IN361=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4627);  
 16971  16
                     stream_IN.add(IN361);
 16972  
 
 16973  
 
 16974  16
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4631);
 16975  16
                     l2=expressionList();
 16976  2158
 
 16977  2174
                     state._fsp--;
 16978  
 
 16979  16
                     stream_expressionList.add(l2.getTree());
 16980  2158
 
 16981  
                     // AST REWRITE
 16982  2158
                     // elements: l2, IN, relationalExpression
 16983  2158
                     // token labels: 
 16984  2158
                     // rule labels: retval, l2
 16985  
                     // token list labels: 
 16986  2158
                     // rule list labels: 
 16987  
                     // wildcard labels: 
 16988  2174
                     retval.tree = root_0;
 16989  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16990  2174
                     RewriteRuleSubtreeStream stream_l2=new RewriteRuleSubtreeStream(adaptor,"rule l2",l2!=null?l2.tree:null);
 16991  
 
 16992  2174
                     root_0 = (Object)adaptor.nil();
 16993  
                     // 530:61: -> ^( IN $relationalExpression $l2)
 16994  2158
                     {
 16995  
                         // com\\googlecode\\sparkleg\\Sparql.g:530:64: ^( IN $relationalExpression $l2)
 16996  
                         {
 16997  2174
                         Object root_1 = (Object)adaptor.nil();
 16998  2174
                         root_1 = (Object)adaptor.becomeRoot(
 16999  2158
                         stream_IN.nextNode()
 17000  2158
                         , root_1);
 17001  2158
 
 17002  2174
                         adaptor.addChild(root_1, stream_retval.nextTree());
 17003  2158
 
 17004  2174
                         adaptor.addChild(root_1, stream_l2.nextTree());
 17005  2158
 
 17006  16
                         adaptor.addChild(root_0, root_1);
 17007  
                         }
 17008  
 
 17009  
                     }
 17010  
 
 17011  
 
 17012  16
                     retval.tree = root_0;
 17013  2158
 
 17014  2158
                     }
 17015  
 
 17016  2158
 
 17017  
                     }
 17018  2174
                     break;
 17019  
                 case 8 :
 17020  
                     // com\\googlecode\\sparkleg\\Sparql.g:531:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 17021  
                     {
 17022  
                     // com\\googlecode\\sparkleg\\Sparql.g:531:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 17023  
                     // com\\googlecode\\sparkleg\\Sparql.g:531:40: NOT IN l3= expressionList
 17024  
                     {
 17025  16
                     NOT362=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression4685);  
 17026  16
                     stream_NOT.add(NOT362);
 17027  2158
 
 17028  2158
 
 17029  2174
                     IN363=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4687);  
 17030  16
                     stream_IN.add(IN363);
 17031  2158
 
 17032  
 
 17033  16
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4691);
 17034  2174
                     l3=expressionList();
 17035  
 
 17036  16
                     state._fsp--;
 17037  
 
 17038  16
                     stream_expressionList.add(l3.getTree());
 17039  2158
 
 17040  
                     // AST REWRITE
 17041  
                     // elements: IN, relationalExpression, l3, NOT
 17042  
                     // token labels: 
 17043  
                     // rule labels: retval, l3
 17044  
                     // token list labels: 
 17045  
                     // rule list labels: 
 17046  
                     // wildcard labels: 
 17047  2320
                     retval.tree = root_0;
 17048  2320
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17049  16
                     RewriteRuleSubtreeStream stream_l3=new RewriteRuleSubtreeStream(adaptor,"rule l3",l3!=null?l3.tree:null);
 17050  
 
 17051  16
                     root_0 = (Object)adaptor.nil();
 17052  106
                     // 531:65: -> ^( NOT IN $relationalExpression $l3)
 17053  
                     {
 17054  106
                         // com\\googlecode\\sparkleg\\Sparql.g:531:68: ^( NOT IN $relationalExpression $l3)
 17055  
                         {
 17056  16
                         Object root_1 = (Object)adaptor.nil();
 17057  16
                         root_1 = (Object)adaptor.becomeRoot(
 17058  
                         stream_NOT.nextNode()
 17059  
                         , root_1);
 17060  
 
 17061  16
                         adaptor.addChild(root_1, 
 17062  40
                         stream_IN.nextNode()
 17063  
                         );
 17064  
 
 17065  16
                         adaptor.addChild(root_1, stream_retval.nextTree());
 17066  
 
 17067  16
                         adaptor.addChild(root_1, stream_l3.nextTree());
 17068  2304
 
 17069  16
                         adaptor.addChild(root_0, root_1);
 17070  
                         }
 17071  
 
 17072  
                     }
 17073  
 
 17074  
 
 17075  122
                     retval.tree = root_0;
 17076  106
 
 17077  
                     }
 17078  106
 
 17079  
 
 17080  106
                     }
 17081  
                     break;
 17082  106
 
 17083  106
             }
 17084  
 
 17085  106
 
 17086  
             }
 17087  106
 
 17088  6948
             retval.stop = input.LT(-1);
 17089  
 
 17090  
 
 17091  6948
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17092  6948
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17093  
 
 17094  
         }
 17095  0
         catch (RecognitionException re) {
 17096  106
             reportError(re);
 17097  106
             recover(input,re);
 17098  106
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17099  
 
 17100  106
         }
 17101  
 
 17102  0
         finally {
 17103  
                 // do for sure before leaving
 17104  6948
         }
 17105  7054
         return retval;
 17106  106
     }
 17107  
     // $ANTLR end "relationalExpression"
 17108  106
 
 17109  
 
 17110  106
     public static class numericExpression_return extends ParserRuleReturnScope {
 17111  
         Object tree;
 17112  106
         public Object getTree() { return tree; }
 17113  
     };
 17114  
 
 17115  
 
 17116  
     // $ANTLR start "numericExpression"
 17117  
     // com\\googlecode\\sparkleg\\Sparql.g:534:1: numericExpression : additiveExpression ;
 17118  106
     public final SparqlParser.numericExpression_return numericExpression() throws RecognitionException {
 17119  8596
         SparqlParser.numericExpression_return retval = new SparqlParser.numericExpression_return();
 17120  8596
         retval.start = input.LT(1);
 17121  
 
 17122  
 
 17123  8596
         Object root_0 = null;
 17124  106
 
 17125  8596
         SparqlParser.additiveExpression_return additiveExpression364 =null;
 17126  
 
 17127  
 
 17128  
 
 17129  40
         try {
 17130  40
             // com\\googlecode\\sparkleg\\Sparql.g:535:5: ( additiveExpression )
 17131  
             // com\\googlecode\\sparkleg\\Sparql.g:535:7: additiveExpression
 17132  
             {
 17133  8596
             root_0 = (Object)adaptor.nil();
 17134  
 
 17135  40
 
 17136  8596
             pushFollow(FOLLOW_additiveExpression_in_numericExpression4725);
 17137  8636
             additiveExpression364=additiveExpression();
 17138  
 
 17139  8596
             state._fsp--;
 17140  
 
 17141  8596
             adaptor.addChild(root_0, additiveExpression364.getTree());
 17142  
 
 17143  
             }
 17144  
 
 17145  8596
             retval.stop = input.LT(-1);
 17146  
 
 17147  
 
 17148  8596
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17149  8596
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17150  
 
 17151  
         }
 17152  0
         catch (RecognitionException re) {
 17153  40
             reportError(re);
 17154  0
             recover(input,re);
 17155  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17156  
 
 17157  40
         }
 17158  40
 
 17159  0
         finally {
 17160  40
                 // do for sure before leaving
 17161  8596
         }
 17162  8636
         return retval;
 17163  
     }
 17164  
     // $ANTLR end "numericExpression"
 17165  
 
 17166  
 
 17167  8596
     public static class additiveExpression_return extends ParserRuleReturnScope {
 17168  
         Object tree;
 17169  8596
         public Object getTree() { return tree; }
 17170  
     };
 17171  40
 
 17172  40
 
 17173  40
     // $ANTLR start "additiveExpression"
 17174  
     // com\\googlecode\\sparkleg\\Sparql.g:538:1: additiveExpression : (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )* ;
 17175  40
     public final SparqlParser.additiveExpression_return additiveExpression() throws RecognitionException {
 17176  8596
         SparqlParser.additiveExpression_return retval = new SparqlParser.additiveExpression_return();
 17177  8596
         retval.start = input.LT(1);
 17178  
 
 17179  
 
 17180  8636
         Object root_0 = null;
 17181  40
 
 17182  8596
         Token char_literal366=null;
 17183  8596
         Token char_literal367=null;
 17184  8596
         SparqlParser.multiplicativeExpression_return m1 =null;
 17185  40
 
 17186  8596
         SparqlParser.multiplicativeExpression_return m2 =null;
 17187  40
 
 17188  8596
         SparqlParser.numericLiteralPositive_return n1 =null;
 17189  40
 
 17190  8596
         SparqlParser.numericLiteralNegative_return n2 =null;
 17191  
 
 17192  8596
         SparqlParser.unaryExpression_return u2 =null;
 17193  
 
 17194  8596
         SparqlParser.additiveOperator_return additiveOperator365 =null;
 17195  40
 
 17196  
 
 17197  8596
         Object char_literal366_tree=null;
 17198  8636
         Object char_literal367_tree=null;
 17199  8596
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 17200  8596
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 17201  8596
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17202  8596
         RewriteRuleSubtreeStream stream_numericLiteralNegative=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralNegative");
 17203  8596
         RewriteRuleSubtreeStream stream_numericLiteralPositive=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralPositive");
 17204  8596
         RewriteRuleSubtreeStream stream_additiveOperator=new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
 17205  8596
         RewriteRuleSubtreeStream stream_multiplicativeExpression=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
 17206  
         try {
 17207  
             // com\\googlecode\\sparkleg\\Sparql.g:539:5: ( (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )* )
 17208  
             // com\\googlecode\\sparkleg\\Sparql.g:539:7: (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )*
 17209  
             {
 17210  
             // com\\googlecode\\sparkleg\\Sparql.g:539:7: (m1= multiplicativeExpression -> $m1)
 17211  
             // com\\googlecode\\sparkleg\\Sparql.g:539:8: m1= multiplicativeExpression
 17212  
             {
 17213  8596
             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4745);
 17214  8596
             m1=multiplicativeExpression();
 17215  
 
 17216  8596
             state._fsp--;
 17217  
 
 17218  8596
             stream_multiplicativeExpression.add(m1.getTree());
 17219  
 
 17220  
             // AST REWRITE
 17221  
             // elements: m1
 17222  
             // token labels: 
 17223  
             // rule labels: retval, m1
 17224  
             // token list labels: 
 17225  
             // rule list labels: 
 17226  
             // wildcard labels: 
 17227  8596
             retval.tree = root_0;
 17228  8596
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17229  8596
             RewriteRuleSubtreeStream stream_m1=new RewriteRuleSubtreeStream(adaptor,"rule m1",m1!=null?m1.tree:null);
 17230  
 
 17231  8596
             root_0 = (Object)adaptor.nil();
 17232  
             // 539:36: -> $m1
 17233  
             {
 17234  8596
                 adaptor.addChild(root_0, stream_m1.nextTree());
 17235  
 
 17236  
             }
 17237  
 
 17238  
 
 17239  8596
             retval.tree = root_0;
 17240  
 
 17241  
             }
 17242  
 
 17243  
 
 17244  
             // com\\googlecode\\sparkleg\\Sparql.g:539:44: ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )? )*
 17245  
             loop120:
 17246  
             do {
 17247  9180
                 int alt120=3;
 17248  9180
                 switch ( input.LA(1) ) {
 17249  40
                 case MINUS:
 17250  40
                 case PLUS:
 17251  
                     {
 17252  484
                     alt120=1;
 17253  
                     }
 17254  484
                     break;
 17255  
                 case DECIMAL_NEGATIVE:
 17256  
                 case DECIMAL_POSITIVE:
 17257  
                 case DOUBLE_NEGATIVE:
 17258  
                 case DOUBLE_POSITIVE:
 17259  
                 case INTEGER_NEGATIVE:
 17260  
                 case INTEGER_POSITIVE:
 17261  
                     {
 17262  100
                     alt120=2;
 17263  40
                     }
 17264  
                     break;
 17265  
 
 17266  
                 }
 17267  
 
 17268  9180
                 switch (alt120) {
 17269  
                     case 1 :
 17270  
                         // com\\googlecode\\sparkleg\\Sparql.g:539:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17271  
                         {
 17272  
                         // com\\googlecode\\sparkleg\\Sparql.g:539:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17273  
                         // com\\googlecode\\sparkleg\\Sparql.g:539:46: additiveOperator m2= multiplicativeExpression
 17274  
                         {
 17275  484
                         pushFollow(FOLLOW_additiveOperator_in_additiveExpression4755);
 17276  484
                         additiveOperator365=additiveOperator();
 17277  
 
 17278  484
                         state._fsp--;
 17279  
 
 17280  484
                         stream_additiveOperator.add(additiveOperator365.getTree());
 17281  
 
 17282  484
                         pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4759);
 17283  484
                         m2=multiplicativeExpression();
 17284  
 
 17285  484
                         state._fsp--;
 17286  
 
 17287  484
                         stream_multiplicativeExpression.add(m2.getTree());
 17288  
 
 17289  
                         // AST REWRITE
 17290  
                         // elements: additiveOperator, additiveExpression, m2
 17291  
                         // token labels: 
 17292  
                         // rule labels: retval, m2
 17293  
                         // token list labels: 
 17294  
                         // rule list labels: 
 17295  
                         // wildcard labels: 
 17296  484
                         retval.tree = root_0;
 17297  484
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17298  484
                         RewriteRuleSubtreeStream stream_m2=new RewriteRuleSubtreeStream(adaptor,"rule m2",m2!=null?m2.tree:null);
 17299  
 
 17300  484
                         root_0 = (Object)adaptor.nil();
 17301  
                         // 539:91: -> ^( additiveOperator $additiveExpression $m2)
 17302  
                         {
 17303  
                             // com\\googlecode\\sparkleg\\Sparql.g:539:94: ^( additiveOperator $additiveExpression $m2)
 17304  
                             {
 17305  484
                             Object root_1 = (Object)adaptor.nil();
 17306  484
                             root_1 = (Object)adaptor.becomeRoot(stream_additiveOperator.nextNode(), root_1);
 17307  
 
 17308  484
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17309  
 
 17310  484
                             adaptor.addChild(root_1, stream_m2.nextTree());
 17311  
 
 17312  484
                             adaptor.addChild(root_0, root_1);
 17313  
                             }
 17314  
 
 17315  
                         }
 17316  
 
 17317  
 
 17318  484
                         retval.tree = root_0;
 17319  
 
 17320  
                         }
 17321  
 
 17322  
 
 17323  
                         }
 17324  484
                         break;
 17325  
                     case 2 :
 17326  
                         // com\\googlecode\\sparkleg\\Sparql.g:540:48: (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) ) ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )?
 17327  
                         {
 17328  
                         // com\\googlecode\\sparkleg\\Sparql.g:540:48: (n1= numericLiteralPositive -> ^( '+' $additiveExpression $n1) |n2= numericLiteralNegative -> ^( '+' $additiveExpression $n2) )
 17329  100
                         int alt118=2;
 17330  100
                         switch ( input.LA(1) ) {
 17331  
                         case DECIMAL_POSITIVE:
 17332  
                         case DOUBLE_POSITIVE:
 17333  
                         case INTEGER_POSITIVE:
 17334  
                             {
 17335  100
                             alt118=1;
 17336  
                             }
 17337  100
                             break;
 17338  
                         case DECIMAL_NEGATIVE:
 17339  
                         case DOUBLE_NEGATIVE:
 17340  
                         case INTEGER_NEGATIVE:
 17341  
                             {
 17342  0
                             alt118=2;
 17343  
                             }
 17344  0
                             break;
 17345  
                         default:
 17346  0
                             NoViableAltException nvae =
 17347  
                                 new NoViableAltException("", 118, 0, input);
 17348  
 
 17349  0
                             throw nvae;
 17350  
 
 17351  
                         }
 17352  
 
 17353  100
                         switch (alt118) {
 17354  
                             case 1 :
 17355  
                                 // com\\googlecode\\sparkleg\\Sparql.g:540:49: n1= numericLiteralPositive
 17356  
                                 {
 17357  100
                                 pushFollow(FOLLOW_numericLiteralPositive_in_additiveExpression4826);
 17358  100
                                 n1=numericLiteralPositive();
 17359  
 
 17360  100
                                 state._fsp--;
 17361  
 
 17362  100
                                 stream_numericLiteralPositive.add(n1.getTree());
 17363  
 
 17364  
                                 // AST REWRITE
 17365  
                                 // elements: additiveExpression, PLUS, n1
 17366  
                                 // token labels: 
 17367  
                                 // rule labels: n1, retval
 17368  
                                 // token list labels: 
 17369  
                                 // rule list labels: 
 17370  
                                 // wildcard labels: 
 17371  100
                                 retval.tree = root_0;
 17372  100
                                 RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 17373  100
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17374  
 
 17375  100
                                 root_0 = (Object)adaptor.nil();
 17376  
                                 // 540:75: -> ^( '+' $additiveExpression $n1)
 17377  
                                 {
 17378  
                                     // com\\googlecode\\sparkleg\\Sparql.g:540:78: ^( '+' $additiveExpression $n1)
 17379  
                                     {
 17380  100
                                     Object root_1 = (Object)adaptor.nil();
 17381  100
                                     root_1 = (Object)adaptor.becomeRoot(
 17382  
                                     (Object)adaptor.create(PLUS, "PLUS")
 17383  
                                     , root_1);
 17384  
 
 17385  100
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17386  
 
 17387  100
                                     adaptor.addChild(root_1, stream_n1.nextTree());
 17388  
 
 17389  100
                                     adaptor.addChild(root_0, root_1);
 17390  
                                     }
 17391  40
 
 17392  
                                 }
 17393  
 
 17394  2158
 
 17395  100
                                 retval.tree = root_0;
 17396  146
 
 17397  
                                 }
 17398  100
                                 break;
 17399  
                             case 2 :
 17400  
                                 // com\\googlecode\\sparkleg\\Sparql.g:540:111: n2= numericLiteralNegative
 17401  2158
                                 {
 17402  0
                                 pushFollow(FOLLOW_numericLiteralNegative_in_additiveExpression4844);
 17403  0
                                 n2=numericLiteralNegative();
 17404  2158
 
 17405  2158
                                 state._fsp--;
 17406  
 
 17407  0
                                 stream_numericLiteralNegative.add(n2.getTree());
 17408  
 
 17409  
                                 // AST REWRITE
 17410  
                                 // elements: PLUS, additiveExpression, n2
 17411  
                                 // token labels: 
 17412  
                                 // rule labels: retval, n2
 17413  
                                 // token list labels: 
 17414  
                                 // rule list labels: 
 17415  
                                 // wildcard labels: 
 17416  0
                                 retval.tree = root_0;
 17417  2158
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17418  2158
                                 RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 17419  
 
 17420  0
                                 root_0 = (Object)adaptor.nil();
 17421  
                                 // 540:137: -> ^( '+' $additiveExpression $n2)
 17422  
                                 {
 17423  106
                                     // com\\googlecode\\sparkleg\\Sparql.g:540:140: ^( '+' $additiveExpression $n2)
 17424  
                                     {
 17425  106
                                     Object root_1 = (Object)adaptor.nil();
 17426  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17427  
                                     (Object)adaptor.create(PLUS, "PLUS")
 17428  
                                     , root_1);
 17429  
 
 17430  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17431  
 
 17432  106
                                     adaptor.addChild(root_1, stream_n2.nextTree());
 17433  106
 
 17434  0
                                     adaptor.addChild(root_0, root_1);
 17435  
                                     }
 17436  106
 
 17437  
                                 }
 17438  106
 
 17439  
 
 17440  106
                                 retval.tree = root_0;
 17441  
 
 17442  
                                 }
 17443  
                                 break;
 17444  
 
 17445  
                         }
 17446  106
 
 17447  
 
 17448  
                         // com\\googlecode\\sparkleg\\Sparql.g:541:46: ( ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) ) | ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) ) )?
 17449  206
                         int alt119=3;
 17450  100
                         switch ( input.LA(1) ) {
 17451  106
                             case ASTERISK:
 17452  106
                                 {
 17453  106
                                 alt119=1;
 17454  
                                 }
 17455  0
                                 break;
 17456  106
                             case DIVIDE:
 17457  
                                 {
 17458  0
                                 alt119=2;
 17459  
                                 }
 17460  
                                 break;
 17461  
                         }
 17462  
 
 17463  100
                         switch (alt119) {
 17464  
                             case 1 :
 17465  
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:47: ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) )
 17466  106
                                 {
 17467  
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:47: ( ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) ) )
 17468  
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:48: ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) )
 17469  106
                                 {
 17470  106
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:48: ( '*' u2= unaryExpression -> ^( '*' $additiveExpression $u2) )
 17471  
                                 // com\\googlecode\\sparkleg\\Sparql.g:541:49: '*' u2= unaryExpression
 17472  
                                 {
 17473  0
                                 char_literal366=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_additiveExpression4908);  
 17474  0
                                 stream_ASTERISK.add(char_literal366);
 17475  
 
 17476  
 
 17477  0
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4912);
 17478  0
                                 u2=unaryExpression();
 17479  
 
 17480  0
                                 state._fsp--;
 17481  
 
 17482  106
                                 stream_unaryExpression.add(u2.getTree());
 17483  106
 
 17484  
                                 // AST REWRITE
 17485  
                                 // elements: u2, additiveExpression, ASTERISK
 17486  
                                 // token labels: 
 17487  
                                 // rule labels: retval, u2
 17488  2264
                                 // token list labels: 
 17489  
                                 // rule list labels: 
 17490  2264
                                 // wildcard labels: 
 17491  0
                                 retval.tree = root_0;
 17492  0
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17493  0
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17494  
 
 17495  0
                                 root_0 = (Object)adaptor.nil();
 17496  
                                 // 541:72: -> ^( '*' $additiveExpression $u2)
 17497  2264
                                 {
 17498  2264
                                     // com\\googlecode\\sparkleg\\Sparql.g:541:75: ^( '*' $additiveExpression $u2)
 17499  
                                     {
 17500  0
                                     Object root_1 = (Object)adaptor.nil();
 17501  2264
                                     root_1 = (Object)adaptor.becomeRoot(
 17502  
                                     stream_ASTERISK.nextNode()
 17503  2264
                                     , root_1);
 17504  
 
 17505  2264
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17506  
 
 17507  2264
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17508  
 
 17509  0
                                     adaptor.addChild(root_0, root_1);
 17510  2264
                                     }
 17511  2264
 
 17512  
                                 }
 17513  
 
 17514  
 
 17515  0
                                 retval.tree = root_0;
 17516  
 
 17517  
                                 }
 17518  
 
 17519  2264
 
 17520  2264
                                 }
 17521  
 
 17522  2264
 
 17523  
                                 }
 17524  2264
                                 break;
 17525  
                             case 2 :
 17526  
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:48: ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) )
 17527  
                                 {
 17528  
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:48: ( ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) ) )
 17529  
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:49: ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) )
 17530  
                                 {
 17531  
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:49: ( '/' u2= unaryExpression -> ^( '/' $additiveExpression $u2) )
 17532  
                                 // com\\googlecode\\sparkleg\\Sparql.g:542:50: '/' u2= unaryExpression
 17533  2264
                                 {
 17534  2264
                                 char_literal367=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_additiveExpression4978);  
 17535  2264
                                 stream_DIVIDE.add(char_literal367);
 17536  
 
 17537  2264
 
 17538  0
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4982);
 17539  0
                                 u2=unaryExpression();
 17540  2264
 
 17541  0
                                 state._fsp--;
 17542  
 
 17543  0
                                 stream_unaryExpression.add(u2.getTree());
 17544  
 
 17545  2264
                                 // AST REWRITE
 17546  
                                 // elements: u2, DIVIDE, additiveExpression
 17547  
                                 // token labels: 
 17548  
                                 // rule labels: retval, u2
 17549  
                                 // token list labels: 
 17550  
                                 // rule list labels: 
 17551  
                                 // wildcard labels: 
 17552  0
                                 retval.tree = root_0;
 17553  2296
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17554  2296
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17555  
 
 17556  0
                                 root_0 = (Object)adaptor.nil();
 17557  
                                 // 542:73: -> ^( '/' $additiveExpression $u2)
 17558  32
                                 {
 17559  
                                     // com\\googlecode\\sparkleg\\Sparql.g:542:76: ^( '/' $additiveExpression $u2)
 17560  
                                     {
 17561  0
                                     Object root_1 = (Object)adaptor.nil();
 17562  0
                                     root_1 = (Object)adaptor.becomeRoot(
 17563  
                                     stream_DIVIDE.nextNode()
 17564  2296
                                     , root_1);
 17565  
 
 17566  0
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17567  
 
 17568  32
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17569  32
 
 17570  0
                                     adaptor.addChild(root_0, root_1);
 17571  32
                                     }
 17572  
 
 17573  32
                                 }
 17574  
 
 17575  32
 
 17576  32
                                 retval.tree = root_0;
 17577  
 
 17578  32
                                 }
 17579  
 
 17580  32
 
 17581  
                                 }
 17582  
 
 17583  
 
 17584  
                                 }
 17585  
                                 break;
 17586  
 
 17587  
                         }
 17588  
 
 17589  32
 
 17590  32
                         }
 17591  132
                         break;
 17592  
 
 17593  32
                     default :
 17594  8596
                         break loop120;
 17595  
                 }
 17596  584
             } while (true);
 17597  
 
 17598  32
 
 17599  32
             }
 17600  
 
 17601  8628
             retval.stop = input.LT(-1);
 17602  
 
 17603  32
 
 17604  8596
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17605  8628
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17606  
 
 17607  
         }
 17608  0
         catch (RecognitionException re) {
 17609  0
             reportError(re);
 17610  0
             recover(input,re);
 17611  32
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17612  
 
 17613  
         }
 17614  32
 
 17615  0
         finally {
 17616  
                 // do for sure before leaving
 17617  10860
         }
 17618  8596
         return retval;
 17619  32
     }
 17620  
     // $ANTLR end "additiveExpression"
 17621  
 
 17622  
 
 17623  484
     public static class additiveOperator_return extends ParserRuleReturnScope {
 17624  2264
         Object tree;
 17625  484
         public Object getTree() { return tree; }
 17626  
     };
 17627  2264
 
 17628  2264
 
 17629  
     // $ANTLR start "additiveOperator"
 17630  
     // com\\googlecode\\sparkleg\\Sparql.g:545:1: additiveOperator : ( '+' | '-' );
 17631  
     public final SparqlParser.additiveOperator_return additiveOperator() throws RecognitionException {
 17632  484
         SparqlParser.additiveOperator_return retval = new SparqlParser.additiveOperator_return();
 17633  484
         retval.start = input.LT(1);
 17634  
 
 17635  
 
 17636  484
         Object root_0 = null;
 17637  
 
 17638  484
         Token set368=null;
 17639  
 
 17640  2748
         Object set368_tree=null;
 17641  2264
 
 17642  
         try {
 17643  
             // com\\googlecode\\sparkleg\\Sparql.g:546:5: ( '+' | '-' )
 17644  
             // com\\googlecode\\sparkleg\\Sparql.g:
 17645  
             {
 17646  484
             root_0 = (Object)adaptor.nil();
 17647  
 
 17648  32
 
 17649  484
             set368=(Token)input.LT(1);
 17650  
 
 17651  484
             if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
 17652  484
                 input.consume();
 17653  484
                 adaptor.addChild(root_0, 
 17654  
                 (Object)adaptor.create(set368)
 17655  32
                 );
 17656  516
                 state.errorRecovery=false;
 17657  
             }
 17658  
             else {
 17659  32
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17660  0
                 throw mse;
 17661  32
             }
 17662  
 
 17663  32
 
 17664  
             }
 17665  
 
 17666  484
             retval.stop = input.LT(-1);
 17667  
 
 17668  
 
 17669  516
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17670  484
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17671  
 
 17672  32
         }
 17673  0
         catch (RecognitionException re) {
 17674  32
             reportError(re);
 17675  32
             recover(input,re);
 17676  32
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17677  
 
 17678  
         }
 17679  32
 
 17680  0
         finally {
 17681  
                 // do for sure before leaving
 17682  484
         }
 17683  484
         return retval;
 17684  
     }
 17685  
     // $ANTLR end "additiveOperator"
 17686  
 
 17687  
 
 17688  9080
     public static class multiplicativeExpression_return extends ParserRuleReturnScope {
 17689  32
         Object tree;
 17690  9080
         public Object getTree() { return tree; }
 17691  
     };
 17692  32
 
 17693  32
 
 17694  
     // $ANTLR start "multiplicativeExpression"
 17695  
     // com\\googlecode\\sparkleg\\Sparql.g:549:1: multiplicativeExpression : (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* ;
 17696  
     public final SparqlParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
 17697  9080
         SparqlParser.multiplicativeExpression_return retval = new SparqlParser.multiplicativeExpression_return();
 17698  9080
         retval.start = input.LT(1);
 17699  
 
 17700  
 
 17701  9080
         Object root_0 = null;
 17702  
 
 17703  9080
         SparqlParser.unaryExpression_return u1 =null;
 17704  
 
 17705  9112
         SparqlParser.unaryExpression_return u2 =null;
 17706  32
 
 17707  9080
         SparqlParser.multiplicativeOperator_return multiplicativeOperator369 =null;
 17708  
 
 17709  
 
 17710  9080
         RewriteRuleSubtreeStream stream_multiplicativeOperator=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
 17711  9080
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17712  
         try {
 17713  2296
             // com\\googlecode\\sparkleg\\Sparql.g:550:5: ( (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* )
 17714  
             // com\\googlecode\\sparkleg\\Sparql.g:550:7: (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17715  
             {
 17716  
             // com\\googlecode\\sparkleg\\Sparql.g:550:7: (u1= unaryExpression -> $u1)
 17717  
             // com\\googlecode\\sparkleg\\Sparql.g:550:8: u1= unaryExpression
 17718  
             {
 17719  9080
             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5048);
 17720  11376
             u1=unaryExpression();
 17721  2296
 
 17722  9080
             state._fsp--;
 17723  
 
 17724  11376
             stream_unaryExpression.add(u1.getTree());
 17725  
 
 17726  2296
             // AST REWRITE
 17727  2296
             // elements: u1
 17728  2296
             // token labels: 
 17729  2296
             // rule labels: retval, u1
 17730  
             // token list labels: 
 17731  2296
             // rule list labels: 
 17732  
             // wildcard labels: 
 17733  11376
             retval.tree = root_0;
 17734  9080
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17735  11376
             RewriteRuleSubtreeStream stream_u1=new RewriteRuleSubtreeStream(adaptor,"rule u1",u1!=null?u1.tree:null);
 17736  
 
 17737  9080
             root_0 = (Object)adaptor.nil();
 17738  2296
             // 550:27: -> $u1
 17739  2296
             {
 17740  11376
                 adaptor.addChild(root_0, stream_u1.nextTree());
 17741  2296
 
 17742  2296
             }
 17743  2296
 
 17744  2296
 
 17745  9080
             retval.tree = root_0;
 17746  
 
 17747  2296
             }
 17748  2296
 
 17749  
 
 17750  
             // com\\googlecode\\sparkleg\\Sparql.g:550:35: ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17751  38
             loop121:
 17752  
             do {
 17753  9246
                 int alt121=2;
 17754  9208
                 switch ( input.LA(1) ) {
 17755  
                 case ASTERISK:
 17756  
                 case DIVIDE:
 17757  
                     {
 17758  128
                     alt121=1;
 17759  
                     }
 17760  
                     break;
 17761  2
 
 17762  
                 }
 17763  2
 
 17764  9208
                 switch (alt121) {
 17765  
                     case 1 :
 17766  
                         // com\\googlecode\\sparkleg\\Sparql.g:550:36: multiplicativeOperator u2= unaryExpression
 17767  
                         {
 17768  128
                         pushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression5057);
 17769  128
                         multiplicativeOperator369=multiplicativeOperator();
 17770  
 
 17771  128
                         state._fsp--;
 17772  
 
 17773  128
                         stream_multiplicativeOperator.add(multiplicativeOperator369.getTree());
 17774  
 
 17775  128
                         pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression5061);
 17776  128
                         u2=unaryExpression();
 17777  
 
 17778  128
                         state._fsp--;
 17779  
 
 17780  128
                         stream_unaryExpression.add(u2.getTree());
 17781  
 
 17782  
                         // AST REWRITE
 17783  
                         // elements: multiplicativeExpression, multiplicativeOperator, u2
 17784  
                         // token labels: 
 17785  
                         // rule labels: retval, u2
 17786  
                         // token list labels: 
 17787  
                         // rule list labels: 
 17788  
                         // wildcard labels: 
 17789  128
                         retval.tree = root_0;
 17790  128
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17791  128
                         RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17792  
 
 17793  128
                         root_0 = (Object)adaptor.nil();
 17794  
                         // 550:78: -> ^( multiplicativeOperator $multiplicativeExpression $u2)
 17795  
                         {
 17796  
                             // com\\googlecode\\sparkleg\\Sparql.g:550:81: ^( multiplicativeOperator $multiplicativeExpression $u2)
 17797  
                             {
 17798  128
                             Object root_1 = (Object)adaptor.nil();
 17799  128
                             root_1 = (Object)adaptor.becomeRoot(stream_multiplicativeOperator.nextNode(), root_1);
 17800  
 
 17801  128
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17802  
 
 17803  128
                             adaptor.addChild(root_1, stream_u2.nextTree());
 17804  
 
 17805  128
                             adaptor.addChild(root_0, root_1);
 17806  
                             }
 17807  
 
 17808  
                         }
 17809  
 
 17810  
 
 17811  128
                         retval.tree = root_0;
 17812  
 
 17813  
                         }
 17814  128
                         break;
 17815  
 
 17816  
                     default :
 17817  9080
                         break loop121;
 17818  
                 }
 17819  128
             } while (true);
 17820  
 
 17821  
 
 17822  
             }
 17823  
 
 17824  9080
             retval.stop = input.LT(-1);
 17825  
 
 17826  
 
 17827  9080
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17828  9080
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17829  
 
 17830  
         }
 17831  0
         catch (RecognitionException re) {
 17832  0
             reportError(re);
 17833  0
             recover(input,re);
 17834  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17835  
 
 17836  
         }
 17837  
 
 17838  0
         finally {
 17839  
                 // do for sure before leaving
 17840  9080
         }
 17841  9080
         return retval;
 17842  
     }
 17843  
     // $ANTLR end "multiplicativeExpression"
 17844  
 
 17845  2252
 
 17846  128
     public static class multiplicativeOperator_return extends ParserRuleReturnScope {
 17847  2252
         Object tree;
 17848  128
         public Object getTree() { return tree; }
 17849  4
     };
 17850  
 
 17851  
 
 17852  4
     // $ANTLR start "multiplicativeOperator"
 17853  
     // com\\googlecode\\sparkleg\\Sparql.g:553:1: multiplicativeOperator : ( '*' | '/' );
 17854  
     public final SparqlParser.multiplicativeOperator_return multiplicativeOperator() throws RecognitionException {
 17855  128
         SparqlParser.multiplicativeOperator_return retval = new SparqlParser.multiplicativeOperator_return();
 17856  2420
         retval.start = input.LT(1);
 17857  
 
 17858  
 
 17859  128
         Object root_0 = null;
 17860  38
 
 17861  166
         Token set370=null;
 17862  
 
 17863  128
         Object set370_tree=null;
 17864  38
 
 17865  38
         try {
 17866  
             // com\\googlecode\\sparkleg\\Sparql.g:554:5: ( '*' | '/' )
 17867  38
             // com\\googlecode\\sparkleg\\Sparql.g:
 17868  
             {
 17869  166
             root_0 = (Object)adaptor.nil();
 17870  
 
 17871  
 
 17872  128
             set370=(Token)input.LT(1);
 17873  
 
 17874  128
             if ( input.LA(1)==ASTERISK||input.LA(1)==DIVIDE ) {
 17875  128
                 input.consume();
 17876  128
                 adaptor.addChild(root_0, 
 17877  
                 (Object)adaptor.create(set370)
 17878  38
                 );
 17879  166
                 state.errorRecovery=false;
 17880  
             }
 17881  38
             else {
 17882  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17883  0
                 throw mse;
 17884  
             }
 17885  
 
 17886  38
 
 17887  38
             }
 17888  
 
 17889  128
             retval.stop = input.LT(-1);
 17890  
 
 17891  38
 
 17892  128
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17893  128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17894  
 
 17895  38
         }
 17896  0
         catch (RecognitionException re) {
 17897  38
             reportError(re);
 17898  0
             recover(input,re);
 17899  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17900  
 
 17901  
         }
 17902  
 
 17903  38
         finally {
 17904  
                 // do for sure before leaving
 17905  128
         }
 17906  166
         return retval;
 17907  
     }
 17908  
     // $ANTLR end "multiplicativeOperator"
 17909  
 
 17910  
 
 17911  9208
     public static class unaryExpression_return extends ParserRuleReturnScope {
 17912  
         Object tree;
 17913  9208
         public Object getTree() { return tree; }
 17914  
     };
 17915  
 
 17916  
 
 17917  
     // $ANTLR start "unaryExpression"
 17918  
     // com\\googlecode\\sparkleg\\Sparql.g:557:1: unaryExpression : ( '!' primaryExpression -> ^( UNARY '!' primaryExpression ) | '+' primaryExpression -> ^( UNARY '+' primaryExpression ) | '-' primaryExpression -> ^( UNARY '-' primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) );
 17919  
     public final SparqlParser.unaryExpression_return unaryExpression() throws RecognitionException {
 17920  9208
         SparqlParser.unaryExpression_return retval = new SparqlParser.unaryExpression_return();
 17921  9208
         retval.start = input.LT(1);
 17922  
 
 17923  
 
 17924  9208
         Object root_0 = null;
 17925  
 
 17926  9208
         Token char_literal371=null;
 17927  9208
         Token char_literal373=null;
 17928  9208
         Token char_literal375=null;
 17929  9208
         SparqlParser.primaryExpression_return primaryExpression372 =null;
 17930  
 
 17931  9208
         SparqlParser.primaryExpression_return primaryExpression374 =null;
 17932  
 
 17933  9208
         SparqlParser.primaryExpression_return primaryExpression376 =null;
 17934  
 
 17935  9208
         SparqlParser.primaryExpression_return primaryExpression377 =null;
 17936  
 
 17937  
 
 17938  9208
         Object char_literal371_tree=null;
 17939  9208
         Object char_literal373_tree=null;
 17940  9208
         Object char_literal375_tree=null;
 17941  9208
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 17942  9208
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 17943  9208
         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 17944  9208
         RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
 17945  
         try {
 17946  
             // com\\googlecode\\sparkleg\\Sparql.g:558:5: ( '!' primaryExpression -> ^( UNARY '!' primaryExpression ) | '+' primaryExpression -> ^( UNARY '+' primaryExpression ) | '-' primaryExpression -> ^( UNARY '-' primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) )
 17947  9208
             int alt122=4;
 17948  9208
             switch ( input.LA(1) ) {
 17949  
             case NEGATION:
 17950  
                 {
 17951  152
                 alt122=1;
 17952  
                 }
 17953  152
                 break;
 17954  
             case PLUS:
 17955  
                 {
 17956  0
                 alt122=2;
 17957  
                 }
 17958  0
                 break;
 17959  
             case MINUS:
 17960  2
                 {
 17961  10
                 alt122=3;
 17962  
                 }
 17963  8
                 break;
 17964  2
             case ABS:
 17965  2
             case AVG:
 17966  
             case BNODE:
 17967  2
             case BOUND:
 17968  
             case CEIL:
 17969  2
             case COALESCE:
 17970  
             case CONCAT:
 17971  
             case CONTAINS:
 17972  
             case COUNT:
 17973  
             case DATATYPE:
 17974  
             case DAY:
 17975  
             case DECIMAL:
 17976  
             case DECIMAL_NEGATIVE:
 17977  
             case DECIMAL_POSITIVE:
 17978  2
             case DOUBLE:
 17979  2
             case DOUBLE_NEGATIVE:
 17980  
             case DOUBLE_POSITIVE:
 17981  2
             case ENCODE_FOR_URI:
 17982  
             case EXISTS:
 17983  
             case FALSE:
 17984  
             case FLOOR:
 17985  
             case GROUP_CONCAT:
 17986  2
             case HOURS:
 17987  2
             case IF:
 17988  
             case INTEGER:
 17989  
             case INTEGER_NEGATIVE:
 17990  
             case INTEGER_POSITIVE:
 17991  2
             case IRI:
 17992  
             case IRI_REF:
 17993  
             case ISBLANK:
 17994  
             case ISIRI:
 17995  2
             case ISLITERAL:
 17996  
             case ISNUMERIC:
 17997  2
             case ISURI:
 17998  
             case LANG:
 17999  
             case LANGMATCHES:
 18000  
             case LCASE:
 18001  
             case MAX:
 18002  
             case MD5:
 18003  2
             case MIN:
 18004  
             case MINUTES:
 18005  
             case MONTH:
 18006  2
             case NOT:
 18007  
             case NOW:
 18008  
             case PNAME_LN:
 18009  
             case PNAME_NS:
 18010  2252
             case RAND:
 18011  2252
             case REGEX:
 18012  
             case REPLACE:
 18013  2252
             case ROUND:
 18014  
             case SAMETERM:
 18015  2252
             case SAMPLE:
 18016  
             case SECONDS:
 18017  
             case SHA1:
 18018  
             case SHA256:
 18019  
             case SHA384:
 18020  
             case SHA512:
 18021  
             case STR:
 18022  
             case STRAFTER:
 18023  
             case STRBEFORE:
 18024  2252
             case STRDT:
 18025  2252
             case STRENDS:
 18026  
             case STRING_LITERAL1:
 18027  2252
             case STRING_LITERAL2:
 18028  
             case STRING_LITERAL_LONG1:
 18029  
             case STRING_LITERAL_LONG2:
 18030  
             case STRLANG:
 18031  
             case STRLEN:
 18032  2252
             case STRSTARTS:
 18033  2252
             case SUBSTR:
 18034  
             case SUM:
 18035  
             case TIMEZONE:
 18036  
             case TRUE:
 18037  2252
             case TZ:
 18038  
             case UCASE:
 18039  2252
             case URI:
 18040  
             case VAR1:
 18041  
             case VAR2:
 18042  
             case YEAR:
 18043  
             case 209:
 18044  
                 {
 18045  11296
                 alt122=4;
 18046  
                 }
 18047  9044
                 break;
 18048  
             default:
 18049  4
                 NoViableAltException nvae =
 18050  
                     new NoViableAltException("", 122, 0, input);
 18051  2292
 
 18052  4
                 throw nvae;
 18053  
 
 18054  2292
             }
 18055  2292
 
 18056  9204
             switch (alt122) {
 18057  
                 case 1 :
 18058  4
                     // com\\googlecode\\sparkleg\\Sparql.g:558:7: '!' primaryExpression
 18059  4
                     {
 18060  156
                     char_literal371=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression5116);  
 18061  156
                     stream_NEGATION.add(char_literal371);
 18062  
 
 18063  
 
 18064  152
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5118);
 18065  152
                     primaryExpression372=primaryExpression();
 18066  
 
 18067  2448
                     state._fsp--;
 18068  2296
 
 18069  152
                     stream_primaryExpression.add(primaryExpression372.getTree());
 18070  
 
 18071  
                     // AST REWRITE
 18072  
                     // elements: primaryExpression, NEGATION
 18073  2292
                     // token labels: 
 18074  
                     // rule labels: retval
 18075  2292
                     // token list labels: 
 18076  
                     // rule list labels: 
 18077  
                     // wildcard labels: 
 18078  152
                     retval.tree = root_0;
 18079  152
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18080  
 
 18081  152
                     root_0 = (Object)adaptor.nil();
 18082  2292
                     // 558:29: -> ^( UNARY '!' primaryExpression )
 18083  2292
                     {
 18084  
                         // com\\googlecode\\sparkleg\\Sparql.g:558:32: ^( UNARY '!' primaryExpression )
 18085  
                         {
 18086  2444
                         Object root_1 = (Object)adaptor.nil();
 18087  152
                         root_1 = (Object)adaptor.becomeRoot(
 18088  2292
                         (Object)adaptor.create(UNARY, "UNARY")
 18089  
                         , root_1);
 18090  2292
 
 18091  152
                         adaptor.addChild(root_1, 
 18092  2292
                         stream_NEGATION.nextNode()
 18093  
                         );
 18094  2292
 
 18095  152
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18096  2292
 
 18097  152
                         adaptor.addChild(root_0, root_1);
 18098  2292
                         }
 18099  
 
 18100  2292
                     }
 18101  
 
 18102  2292
 
 18103  152
                     retval.tree = root_0;
 18104  
 
 18105  
                     }
 18106  152
                     break;
 18107  
                 case 2 :
 18108  2292
                     // com\\googlecode\\sparkleg\\Sparql.g:559:7: '+' primaryExpression
 18109  2292
                     {
 18110  0
                     char_literal373=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression5136);  
 18111  0
                     stream_PLUS.add(char_literal373);
 18112  48
 
 18113  
 
 18114  48
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5138);
 18115  0
                     primaryExpression374=primaryExpression();
 18116  
 
 18117  0
                     state._fsp--;
 18118  
 
 18119  0
                     stream_primaryExpression.add(primaryExpression374.getTree());
 18120  
 
 18121  
                     // AST REWRITE
 18122  
                     // elements: primaryExpression, PLUS
 18123  
                     // token labels: 
 18124  
                     // rule labels: retval
 18125  
                     // token list labels: 
 18126  
                     // rule list labels: 
 18127  
                     // wildcard labels: 
 18128  0
                     retval.tree = root_0;
 18129  0
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18130  
 
 18131  0
                     root_0 = (Object)adaptor.nil();
 18132  
                     // 559:29: -> ^( UNARY '+' primaryExpression )
 18133  
                     {
 18134  
                         // com\\googlecode\\sparkleg\\Sparql.g:559:32: ^( UNARY '+' primaryExpression )
 18135  
                         {
 18136  0
                         Object root_1 = (Object)adaptor.nil();
 18137  0
                         root_1 = (Object)adaptor.becomeRoot(
 18138  
                         (Object)adaptor.create(UNARY, "UNARY")
 18139  
                         , root_1);
 18140  
 
 18141  0
                         adaptor.addChild(root_1, 
 18142  
                         stream_PLUS.nextNode()
 18143  
                         );
 18144  
 
 18145  0
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18146  
 
 18147  0
                         adaptor.addChild(root_0, root_1);
 18148  
                         }
 18149  
 
 18150  
                     }
 18151  
 
 18152  
 
 18153  0
                     retval.tree = root_0;
 18154  
 
 18155  
                     }
 18156  0
                     break;
 18157  
                 case 3 :
 18158  
                     // com\\googlecode\\sparkleg\\Sparql.g:560:7: '-' primaryExpression
 18159  
                     {
 18160  8
                     char_literal375=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression5156);  
 18161  8
                     stream_MINUS.add(char_literal375);
 18162  
 
 18163  
 
 18164  8
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5158);
 18165  8
                     primaryExpression376=primaryExpression();
 18166  
 
 18167  8
                     state._fsp--;
 18168  374
 
 18169  8
                     stream_primaryExpression.add(primaryExpression376.getTree());
 18170  374
 
 18171  
                     // AST REWRITE
 18172  
                     // elements: MINUS, primaryExpression
 18173  
                     // token labels: 
 18174  
                     // rule labels: retval
 18175  176
                     // token list labels: 
 18176  
                     // rule list labels: 
 18177  176
                     // wildcard labels: 
 18178  8
                     retval.tree = root_0;
 18179  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18180  
 
 18181  8
                     root_0 = (Object)adaptor.nil();
 18182  
                     // 560:29: -> ^( UNARY '-' primaryExpression )
 18183  208
                     {
 18184  
                         // com\\googlecode\\sparkleg\\Sparql.g:560:32: ^( UNARY '-' primaryExpression )
 18185  208
                         {
 18186  8
                         Object root_1 = (Object)adaptor.nil();
 18187  8
                         root_1 = (Object)adaptor.becomeRoot(
 18188  
                         (Object)adaptor.create(UNARY, "UNARY")
 18189  
                         , root_1);
 18190  
 
 18191  8
                         adaptor.addChild(root_1, 
 18192  
                         stream_MINUS.nextNode()
 18193  
                         );
 18194  
 
 18195  8
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18196  186
 
 18197  8
                         adaptor.addChild(root_0, root_1);
 18198  186
                         }
 18199  
 
 18200  
                     }
 18201  
 
 18202  12
 
 18203  8
                     retval.tree = root_0;
 18204  12
 
 18205  
                     }
 18206  8
                     break;
 18207  
                 case 4 :
 18208  1182
                     // com\\googlecode\\sparkleg\\Sparql.g:561:7: primaryExpression
 18209  
                     {
 18210  10226
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression5176);
 18211  9044
                     primaryExpression377=primaryExpression();
 18212  
 
 18213  9044
                     state._fsp--;
 18214  
 
 18215  9044
                     stream_primaryExpression.add(primaryExpression377.getTree());
 18216  
 
 18217  
                     // AST REWRITE
 18218  
                     // elements: primaryExpression
 18219  106
                     // token labels: 
 18220  
                     // rule labels: retval
 18221  106
                     // token list labels: 
 18222  
                     // rule list labels: 
 18223  
                     // wildcard labels: 
 18224  9044
                     retval.tree = root_0;
 18225  9044
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18226  
 
 18227  9044
                     root_0 = (Object)adaptor.nil();
 18228  
                     // 561:25: -> ^( UNARY primaryExpression )
 18229  
                     {
 18230  2292
                         // com\\googlecode\\sparkleg\\Sparql.g:561:28: ^( UNARY primaryExpression )
 18231  
                         {
 18232  9044
                         Object root_1 = (Object)adaptor.nil();
 18233  9044
                         root_1 = (Object)adaptor.becomeRoot(
 18234  48
                         (Object)adaptor.create(UNARY, "UNARY")
 18235  
                         , root_1);
 18236  
 
 18237  9092
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 18238  48
 
 18239  9044
                         adaptor.addChild(root_0, root_1);
 18240  48
                         }
 18241  
 
 18242  48
                     }
 18243  
 
 18244  
 
 18245  9092
                     retval.tree = root_0;
 18246  
 
 18247  
                     }
 18248  
                     break;
 18249  374
 
 18250  
             }
 18251  9204
             retval.stop = input.LT(-1);
 18252  374
 
 18253  374
 
 18254  9204
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18255  9578
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18256  
 
 18257  374
         }
 18258  4
         catch (RecognitionException re) {
 18259  4
             reportError(re);
 18260  378
             recover(input,re);
 18261  4
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18262  
 
 18263  
         }
 18264  176
 
 18265  0
         finally {
 18266  
                 // do for sure before leaving
 18267  9384
         }
 18268  9384
         return retval;
 18269  
     }
 18270  176
     // $ANTLR end "unaryExpression"
 18271  
 
 18272  176
 
 18273  9204
     public static class primaryExpression_return extends ParserRuleReturnScope {
 18274  
         Object tree;
 18275  176
         public Object getTree() { return tree; }
 18276  
     };
 18277  
 
 18278  
 
 18279  208
     // $ANTLR start "primaryExpression"
 18280  
     // com\\googlecode\\sparkleg\\Sparql.g:564:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 18281  
     public final SparqlParser.primaryExpression_return primaryExpression() throws RecognitionException {
 18282  9412
         SparqlParser.primaryExpression_return retval = new SparqlParser.primaryExpression_return();
 18283  9412
         retval.start = input.LT(1);
 18284  
 
 18285  208
 
 18286  9204
         Object root_0 = null;
 18287  208
 
 18288  9204
         SparqlParser.brackettedExpression_return brackettedExpression378 =null;
 18289  
 
 18290  9412
         SparqlParser.builtInCall_return builtInCall379 =null;
 18291  
 
 18292  9204
         SparqlParser.iriRefOrFunction_return iriRefOrFunction380 =null;
 18293  
 
 18294  9390
         SparqlParser.rdfLiteral_return rdfLiteral381 =null;
 18295  
 
 18296  9204
         SparqlParser.numericLiteral_return numericLiteral382 =null;
 18297  186
 
 18298  9390
         SparqlParser.booleanLiteral_return booleanLiteral383 =null;
 18299  
 
 18300  9390
         SparqlParser.var_return var384 =null;
 18301  
 
 18302  9390
         SparqlParser.aggregate_return aggregate385 =null;
 18303  
 
 18304  
 
 18305  186
 
 18306  
         try {
 18307  
             // com\\googlecode\\sparkleg\\Sparql.g:565:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 18308  9204
             int alt123=8;
 18309  9216
             switch ( input.LA(1) ) {
 18310  
             case 209:
 18311  
                 {
 18312  204
                 alt123=1;
 18313  12
                 }
 18314  192
                 break;
 18315  12
             case ABS:
 18316  
             case BNODE:
 18317  12
             case BOUND:
 18318  
             case CEIL:
 18319  
             case COALESCE:
 18320  12
             case CONCAT:
 18321  
             case CONTAINS:
 18322  
             case DATATYPE:
 18323  
             case DAY:
 18324  1182
             case ENCODE_FOR_URI:
 18325  
             case EXISTS:
 18326  
             case FLOOR:
 18327  1182
             case HOURS:
 18328  1182
             case IF:
 18329  
             case IRI:
 18330  1182
             case ISBLANK:
 18331  
             case ISIRI:
 18332  1182
             case ISLITERAL:
 18333  
             case ISNUMERIC:
 18334  
             case ISURI:
 18335  1182
             case LANG:
 18336  
             case LANGMATCHES:
 18337  
             case LCASE:
 18338  
             case MD5:
 18339  106
             case MINUTES:
 18340  
             case MONTH:
 18341  
             case NOT:
 18342  106
             case NOW:
 18343  106
             case RAND:
 18344  
             case REGEX:
 18345  106
             case REPLACE:
 18346  
             case ROUND:
 18347  106
             case SAMETERM:
 18348  
             case SECONDS:
 18349  
             case SHA1:
 18350  
             case SHA256:
 18351  
             case SHA384:
 18352  
             case SHA512:
 18353  2292
             case STR:
 18354  
             case STRAFTER:
 18355  
             case STRBEFORE:
 18356  2292
             case STRDT:
 18357  2292
             case STRENDS:
 18358  
             case STRLANG:
 18359  
             case STRLEN:
 18360  
             case STRSTARTS:
 18361  
             case SUBSTR:
 18362  
             case TIMEZONE:
 18363  
             case TZ:
 18364  
             case UCASE:
 18365  
             case URI:
 18366  
             case YEAR:
 18367  
                 {
 18368  1496
                 alt123=2;
 18369  2292
                 }
 18370  3788
                 break;
 18371  
             case IRI_REF:
 18372  
             case PNAME_LN:
 18373  
             case PNAME_NS:
 18374  
                 {
 18375  704
                 alt123=3;
 18376  
                 }
 18377  704
                 break;
 18378  
             case STRING_LITERAL1:
 18379  
             case STRING_LITERAL2:
 18380  
             case STRING_LITERAL_LONG1:
 18381  
             case STRING_LITERAL_LONG2:
 18382  
                 {
 18383  832
                 alt123=4;
 18384  544
                 }
 18385  1376
                 break;
 18386  
             case DECIMAL:
 18387  
             case DECIMAL_NEGATIVE:
 18388  544
             case DECIMAL_POSITIVE:
 18389  
             case DOUBLE:
 18390  544
             case DOUBLE_NEGATIVE:
 18391  544
             case DOUBLE_POSITIVE:
 18392  544
             case INTEGER:
 18393  
             case INTEGER_NEGATIVE:
 18394  
             case INTEGER_POSITIVE:
 18395  544
                 {
 18396  1348
                 alt123=5;
 18397  544
                 }
 18398  1348
                 break;
 18399  544
             case FALSE:
 18400  
             case TRUE:
 18401  
                 {
 18402  48
                 alt123=6;
 18403  
                 }
 18404  592
                 break;
 18405  544
             case VAR1:
 18406  
             case VAR2:
 18407  
                 {
 18408  5248
                 alt123=7;
 18409  544
                 }
 18410  4704
                 break;
 18411  544
             case AVG:
 18412  
             case COUNT:
 18413  544
             case GROUP_CONCAT:
 18414  
             case MAX:
 18415  544
             case MIN:
 18416  544
             case SAMPLE:
 18417  
             case SUM:
 18418  
                 {
 18419  424
                 alt123=8;
 18420  
                 }
 18421  424
                 break;
 18422  
             default:
 18423  0
                 NoViableAltException nvae =
 18424  
                     new NoViableAltException("", 123, 0, input);
 18425  
 
 18426  544
                 throw nvae;
 18427  544
 
 18428  
             }
 18429  544
 
 18430  9204
             switch (alt123) {
 18431  
                 case 1 :
 18432  
                     // com\\googlecode\\sparkleg\\Sparql.g:565:7: brackettedExpression
 18433  
                     {
 18434  736
                     root_0 = (Object)adaptor.nil();
 18435  544
 
 18436  
 
 18437  192
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression5201);
 18438  192
                     brackettedExpression378=brackettedExpression();
 18439  544
 
 18440  192
                     state._fsp--;
 18441  544
 
 18442  192
                     adaptor.addChild(root_0, brackettedExpression378.getTree());
 18443  
 
 18444  
                     }
 18445  192
                     break;
 18446  
                 case 2 :
 18447  544
                     // com\\googlecode\\sparkleg\\Sparql.g:565:30: builtInCall
 18448  
                     {
 18449  1496
                     root_0 = (Object)adaptor.nil();
 18450  
 
 18451  544
 
 18452  1496
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression5205);
 18453  1496
                     builtInCall379=builtInCall();
 18454  544
 
 18455  2040
                     state._fsp--;
 18456  
 
 18457  1496
                     adaptor.addChild(root_0, builtInCall379.getTree());
 18458  
 
 18459  
                     }
 18460  1496
                     break;
 18461  
                 case 3 :
 18462  
                     // com\\googlecode\\sparkleg\\Sparql.g:565:44: iriRefOrFunction
 18463  
                     {
 18464  704
                     root_0 = (Object)adaptor.nil();
 18465  
 
 18466  
 
 18467  1248
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression5209);
 18468  1248
                     iriRefOrFunction380=iriRefOrFunction();
 18469  
 
 18470  704
                     state._fsp--;
 18471  
 
 18472  704
                     adaptor.addChild(root_0, iriRefOrFunction380.getTree());
 18473  532
 
 18474  
                     }
 18475  704
                     break;
 18476  
                 case 4 :
 18477  
                     // com\\googlecode\\sparkleg\\Sparql.g:565:63: rdfLiteral
 18478  
                     {
 18479  832
                     root_0 = (Object)adaptor.nil();
 18480  
 
 18481  
 
 18482  1364
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression5213);
 18483  1364
                     rdfLiteral381=rdfLiteral();
 18484  
 
 18485  832
                     state._fsp--;
 18486  532
 
 18487  832
                     adaptor.addChild(root_0, rdfLiteral381.getTree());
 18488  532
 
 18489  532
                     }
 18490  1364
                     break;
 18491  532
                 case 5 :
 18492  532
                     // com\\googlecode\\sparkleg\\Sparql.g:565:76: numericLiteral
 18493  532
                     {
 18494  1336
                     root_0 = (Object)adaptor.nil();
 18495  532
 
 18496  532
 
 18497  1336
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression5217);
 18498  1336
                     numericLiteral382=numericLiteral();
 18499  532
 
 18500  1336
                     state._fsp--;
 18501  532
 
 18502  1336
                     adaptor.addChild(root_0, numericLiteral382.getTree());
 18503  532
 
 18504  532
                     }
 18505  1336
                     break;
 18506  532
                 case 6 :
 18507  532
                     // com\\googlecode\\sparkleg\\Sparql.g:565:93: booleanLiteral
 18508  532
                     {
 18509  580
                     root_0 = (Object)adaptor.nil();
 18510  532
 
 18511  532
 
 18512  580
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression5221);
 18513  580
                     booleanLiteral383=booleanLiteral();
 18514  532
 
 18515  580
                     state._fsp--;
 18516  532
 
 18517  580
                     adaptor.addChild(root_0, booleanLiteral383.getTree());
 18518  532
 
 18519  532
                     }
 18520  580
                     break;
 18521  532
                 case 7 :
 18522  532
                     // com\\googlecode\\sparkleg\\Sparql.g:565:110: var
 18523  532
                     {
 18524  5236
                     root_0 = (Object)adaptor.nil();
 18525  532
 
 18526  532
 
 18527  5236
                     pushFollow(FOLLOW_var_in_primaryExpression5225);
 18528  5236
                     var384=var();
 18529  532
 
 18530  5236
                     state._fsp--;
 18531  532
 
 18532  5236
                     adaptor.addChild(root_0, var384.getTree());
 18533  532
 
 18534  532
                     }
 18535  5236
                     break;
 18536  532
                 case 8 :
 18537  532
                     // com\\googlecode\\sparkleg\\Sparql.g:565:116: aggregate
 18538  532
                     {
 18539  956
                     root_0 = (Object)adaptor.nil();
 18540  532
 
 18541  532
 
 18542  956
                     pushFollow(FOLLOW_aggregate_in_primaryExpression5229);
 18543  956
                     aggregate385=aggregate();
 18544  532
 
 18545  956
                     state._fsp--;
 18546  532
 
 18547  956
                     adaptor.addChild(root_0, aggregate385.getTree());
 18548  532
 
 18549  532
                     }
 18550  532
                     break;
 18551  532
 
 18552  532
             }
 18553  9736
             retval.stop = input.LT(-1);
 18554  532
 
 18555  532
 
 18556  9736
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18557  9736
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18558  532
 
 18559  532
         }
 18560  532
         catch (RecognitionException re) {
 18561  532
             reportError(re);
 18562  532
             recover(input,re);
 18563  532
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18564  532
 
 18565  532
         }
 18566  532
 
 18567  532
         finally {
 18568  532
                 // do for sure before leaving
 18569  9736
         }
 18570  9736
         return retval;
 18571  532
     }
 18572  532
     // $ANTLR end "primaryExpression"
 18573  532
 
 18574  532
 
 18575  532
     public static class brackettedExpression_return extends ParserRuleReturnScope {
 18576  532
         Object tree;
 18577  532
         public Object getTree() { return tree; }
 18578  532
     };
 18579  532
 
 18580  532
 
 18581  532
     // $ANTLR start "brackettedExpression"
 18582  532
     // com\\googlecode\\sparkleg\\Sparql.g:568:1: brackettedExpression : '(' expression ')' -> ^( BRACKETTED_EXPRESSION expression ) ;
 18583  532
     public final SparqlParser.brackettedExpression_return brackettedExpression() throws RecognitionException {
 18584  2672
         SparqlParser.brackettedExpression_return retval = new SparqlParser.brackettedExpression_return();
 18585  2672
         retval.start = input.LT(1);
 18586  532
 
 18587  532
 
 18588  2672
         Object root_0 = null;
 18589  532
 
 18590  2672
         Token char_literal386=null;
 18591  2672
         Token char_literal388=null;
 18592  2672
         SparqlParser.expression_return expression387 =null;
 18593  532
 
 18594  532
 
 18595  2672
         Object char_literal386_tree=null;
 18596  2672
         Object char_literal388_tree=null;
 18597  2672
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 18598  2672
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 18599  2672
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18600  532
         try {
 18601  532
             // com\\googlecode\\sparkleg\\Sparql.g:569:5: ( '(' expression ')' -> ^( BRACKETTED_EXPRESSION expression ) )
 18602  532
             // com\\googlecode\\sparkleg\\Sparql.g:569:7: '(' expression ')'
 18603  532
             {
 18604  2672
             char_literal386=(Token)match(input,209,FOLLOW_209_in_brackettedExpression5246);  
 18605  2672
             stream_209.add(char_literal386);
 18606  532
 
 18607  532
 
 18608  2672
             pushFollow(FOLLOW_expression_in_brackettedExpression5248);
 18609  2672
             expression387=expression();
 18610  532
 
 18611  2672
             state._fsp--;
 18612  532
 
 18613  2672
             stream_expression.add(expression387.getTree());
 18614  532
 
 18615  2672
             char_literal388=(Token)match(input,210,FOLLOW_210_in_brackettedExpression5250);  
 18616  2672
             stream_210.add(char_literal388);
 18617  532
 
 18618  532
 
 18619  532
             // AST REWRITE
 18620  532
             // elements: expression
 18621  532
             // token labels: 
 18622  532
             // rule labels: retval
 18623  532
             // token list labels: 
 18624  532
             // rule list labels: 
 18625  532
             // wildcard labels: 
 18626  2672
             retval.tree = root_0;
 18627  2672
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18628  532
 
 18629  2672
             root_0 = (Object)adaptor.nil();
 18630  532
             // 569:26: -> ^( BRACKETTED_EXPRESSION expression )
 18631  532
             {
 18632  532
                 // com\\googlecode\\sparkleg\\Sparql.g:569:29: ^( BRACKETTED_EXPRESSION expression )
 18633  532
                 {
 18634  2140
                 Object root_1 = (Object)adaptor.nil();
 18635  2672
                 root_1 = (Object)adaptor.becomeRoot(
 18636  
                 (Object)adaptor.create(BRACKETTED_EXPRESSION, "BRACKETTED_EXPRESSION")
 18637  532
                 , root_1);
 18638  
 
 18639  2672
                 adaptor.addChild(root_1, stream_expression.nextTree());
 18640  
 
 18641  2672
                 adaptor.addChild(root_0, root_1);
 18642  
                 }
 18643  532
 
 18644  
             }
 18645  532
 
 18646  
 
 18647  2672
             retval.tree = root_0;
 18648  
 
 18649  532
             }
 18650  
 
 18651  2672
             retval.stop = input.LT(-1);
 18652  
 
 18653  532
 
 18654  2140
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18655  2672
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18656  
 
 18657  532
         }
 18658  0
         catch (RecognitionException re) {
 18659  532
             reportError(re);
 18660  0
             recover(input,re);
 18661  532
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18662  
 
 18663  532
         }
 18664  
 
 18665  532
         finally {
 18666  
                 // do for sure before leaving
 18667  2672
         }
 18668  2140
         return retval;
 18669  532
     }
 18670  
     // $ANTLR end "brackettedExpression"
 18671  532
 
 18672  
 
 18673  532
     public static class builtInCall_return extends ParserRuleReturnScope {
 18674  
         Object tree;
 18675  532
         public Object getTree() { return tree; }
 18676  
     };
 18677  532
 
 18678  
 
 18679  532
     // $ANTLR start "builtInCall"
 18680  
     // com\\googlecode\\sparkleg\\Sparql.g:572:1: builtInCall : ( STR '(' expression ')' -> ^( STR expression ) | LANG '(' expression ')' -> ^( LANG expression ) | LANGMATCHES '(' expression ',' expression ')' -> ^( LANGMATCHES ( expression )+ ) | DATATYPE '(' expression ')' -> ^( DATATYPE expression ) | BOUND '(' var ')' -> ^( BOUND var ) | IRI '(' expression ')' -> ^( IRI expression ) | URI '(' expression ')' -> ^( URI expression ) | BNODE ( '(' expression ')' ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS '(' expression ')' -> ^( ABS expression ) | CEIL '(' expression ')' -> ^( CEIL expression ) | FLOOR '(' expression ')' -> ^( FLOOR expression ) | ROUND '(' expression ')' -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | strReplaceExpression -> strReplaceExpression | STRLEN '(' expression ')' -> ^( STRLEN expression ) | UCASE '(' expression ')' -> ^( UCASE expression ) | LCASE '(' expression ')' -> ^( LCASE expression ) | ENCODE_FOR_URI '(' expression ')' -> ^( ENCODE_FOR_URI expression ) | CONTAINS '(' expression ',' expression ')' -> ^( CONTAINS expression expression ) | STRSTARTS '(' expression ',' expression ')' -> ^( STRSTARTS expression expression ) | STRENDS '(' expression ',' expression ')' -> ^( STRENDS expression expression ) | STRBEFORE '(' expression ',' expression ')' -> ^( STRBEFORE expression expression ) | STRAFTER '(' expression ',' expression ')' -> ^( STRAFTER expression expression ) | YEAR '(' expression ')' -> ^( YEAR expression ) | MONTH '(' expression ')' -> ^( MONTH expression ) | DAY '(' expression ')' -> ^( DAY expression ) | HOURS '(' expression ')' -> ^( HOURS expression ) | MINUTES '(' expression ')' -> ^( MINUTES expression ) | SECONDS '(' expression ')' -> ^( SECONDS expression ) | TIMEZONE '(' expression ')' -> ^( TIMEZONE expression ) | TZ '(' expression ')' -> ^( TZ expression ) | NOW nil -> NOW | MD5 '(' expression ')' -> ^( MD5 expression ) | SHA1 '(' expression ')' -> ^( SHA1 expression ) | SHA256 '(' expression ')' -> ^( SHA256 expression ) | SHA384 '(' expression ')' -> ^( SHA384 expression ) | SHA512 '(' expression ')' -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF '(' e1= expression ',' e2= expression ',' e3= expression ')' -> ^( IF $e1 $e2 $e3) | STRLANG '(' expression ',' expression ')' -> ^( STRLANG expression expression ) | STRDT '(' expression ',' expression ')' -> ^( STRDT expression expression ) | SAMETERM '(' expression ',' expression ')' -> ^( SAMETERM expression expression ) | ISIRI '(' expression ')' -> ^( ISIRI expression ) | ISURI '(' expression ')' -> ^( ISURI expression ) | ISBLANK '(' expression ')' -> ^( ISBLANK expression ) | ISLITERAL '(' expression ')' -> ^( ISLITERAL expression ) | ISNUMERIC '(' expression ')' -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction );
 18681  532
     public final SparqlParser.builtInCall_return builtInCall() throws RecognitionException {
 18682  2128
         SparqlParser.builtInCall_return retval = new SparqlParser.builtInCall_return();
 18683  2660
         retval.start = input.LT(1);
 18684  
 
 18685  532
 
 18686  2128
         Object root_0 = null;
 18687  532
 
 18688  2128
         Token STR389=null;
 18689  2660
         Token char_literal390=null;
 18690  2128
         Token char_literal392=null;
 18691  2660
         Token LANG393=null;
 18692  2128
         Token char_literal394=null;
 18693  2660
         Token char_literal396=null;
 18694  2128
         Token LANGMATCHES397=null;
 18695  2660
         Token char_literal398=null;
 18696  2128
         Token char_literal400=null;
 18697  2660
         Token char_literal402=null;
 18698  2128
         Token DATATYPE403=null;
 18699  2660
         Token char_literal404=null;
 18700  2128
         Token char_literal406=null;
 18701  2660
         Token BOUND407=null;
 18702  2128
         Token char_literal408=null;
 18703  2660
         Token char_literal410=null;
 18704  2128
         Token IRI411=null;
 18705  2660
         Token char_literal412=null;
 18706  2128
         Token char_literal414=null;
 18707  2660
         Token URI415=null;
 18708  2128
         Token char_literal416=null;
 18709  2660
         Token char_literal418=null;
 18710  2128
         Token BNODE419=null;
 18711  2660
         Token char_literal420=null;
 18712  2128
         Token char_literal422=null;
 18713  2660
         Token BNODE423=null;
 18714  2128
         Token RAND425=null;
 18715  2660
         Token ABS427=null;
 18716  2128
         Token char_literal428=null;
 18717  2660
         Token char_literal430=null;
 18718  2128
         Token CEIL431=null;
 18719  2660
         Token char_literal432=null;
 18720  2128
         Token char_literal434=null;
 18721  2660
         Token FLOOR435=null;
 18722  2128
         Token char_literal436=null;
 18723  2660
         Token char_literal438=null;
 18724  2128
         Token ROUND439=null;
 18725  2660
         Token char_literal440=null;
 18726  2128
         Token char_literal442=null;
 18727  2660
         Token CONCAT443=null;
 18728  2128
         Token STRLEN447=null;
 18729  2660
         Token char_literal448=null;
 18730  2128
         Token char_literal450=null;
 18731  2660
         Token UCASE451=null;
 18732  2128
         Token char_literal452=null;
 18733  2660
         Token char_literal454=null;
 18734  2128
         Token LCASE455=null;
 18735  2660
         Token char_literal456=null;
 18736  2128
         Token char_literal458=null;
 18737  2660
         Token ENCODE_FOR_URI459=null;
 18738  2128
         Token char_literal460=null;
 18739  2660
         Token char_literal462=null;
 18740  2128
         Token CONTAINS463=null;
 18741  2660
         Token char_literal464=null;
 18742  2128
         Token char_literal466=null;
 18743  2660
         Token char_literal468=null;
 18744  2128
         Token STRSTARTS469=null;
 18745  2660
         Token char_literal470=null;
 18746  2128
         Token char_literal472=null;
 18747  2660
         Token char_literal474=null;
 18748  2128
         Token STRENDS475=null;
 18749  2660
         Token char_literal476=null;
 18750  2128
         Token char_literal478=null;
 18751  2660
         Token char_literal480=null;
 18752  2128
         Token STRBEFORE481=null;
 18753  2660
         Token char_literal482=null;
 18754  2128
         Token char_literal484=null;
 18755  2660
         Token char_literal486=null;
 18756  2128
         Token STRAFTER487=null;
 18757  2660
         Token char_literal488=null;
 18758  2128
         Token char_literal490=null;
 18759  2660
         Token char_literal492=null;
 18760  2128
         Token YEAR493=null;
 18761  2128
         Token char_literal494=null;
 18762  2660
         Token char_literal496=null;
 18763  2660
         Token MONTH497=null;
 18764  2660
         Token char_literal498=null;
 18765  2660
         Token char_literal500=null;
 18766  2660
         Token DAY501=null;
 18767  2660
         Token char_literal502=null;
 18768  2660
         Token char_literal504=null;
 18769  2660
         Token HOURS505=null;
 18770  2660
         Token char_literal506=null;
 18771  2660
         Token char_literal508=null;
 18772  2660
         Token MINUTES509=null;
 18773  2660
         Token char_literal510=null;
 18774  2660
         Token char_literal512=null;
 18775  2660
         Token SECONDS513=null;
 18776  2660
         Token char_literal514=null;
 18777  2660
         Token char_literal516=null;
 18778  2660
         Token TIMEZONE517=null;
 18779  2660
         Token char_literal518=null;
 18780  2660
         Token char_literal520=null;
 18781  2660
         Token TZ521=null;
 18782  2660
         Token char_literal522=null;
 18783  2660
         Token char_literal524=null;
 18784  2660
         Token NOW525=null;
 18785  2660
         Token MD5527=null;
 18786  2660
         Token char_literal528=null;
 18787  2660
         Token char_literal530=null;
 18788  2660
         Token SHA1531=null;
 18789  2660
         Token char_literal532=null;
 18790  2660
         Token char_literal534=null;
 18791  2660
         Token SHA256535=null;
 18792  2660
         Token char_literal536=null;
 18793  2660
         Token char_literal538=null;
 18794  2660
         Token SHA384539=null;
 18795  2660
         Token char_literal540=null;
 18796  2660
         Token char_literal542=null;
 18797  2660
         Token SHA512543=null;
 18798  2660
         Token char_literal544=null;
 18799  2660
         Token char_literal546=null;
 18800  2660
         Token COALESCE547=null;
 18801  2660
         Token IF549=null;
 18802  2660
         Token char_literal550=null;
 18803  2660
         Token char_literal551=null;
 18804  2660
         Token char_literal552=null;
 18805  2660
         Token char_literal553=null;
 18806  2660
         Token STRLANG554=null;
 18807  2660
         Token char_literal555=null;
 18808  2660
         Token char_literal557=null;
 18809  2660
         Token char_literal559=null;
 18810  2660
         Token STRDT560=null;
 18811  2660
         Token char_literal561=null;
 18812  2660
         Token char_literal563=null;
 18813  2660
         Token char_literal565=null;
 18814  2660
         Token SAMETERM566=null;
 18815  2660
         Token char_literal567=null;
 18816  2660
         Token char_literal569=null;
 18817  2660
         Token char_literal571=null;
 18818  2660
         Token ISIRI572=null;
 18819  2660
         Token char_literal573=null;
 18820  2660
         Token char_literal575=null;
 18821  2660
         Token ISURI576=null;
 18822  2660
         Token char_literal577=null;
 18823  2660
         Token char_literal579=null;
 18824  2660
         Token ISBLANK580=null;
 18825  2660
         Token char_literal581=null;
 18826  2660
         Token char_literal583=null;
 18827  2660
         Token ISLITERAL584=null;
 18828  2660
         Token char_literal585=null;
 18829  2660
         Token char_literal587=null;
 18830  2660
         Token ISNUMERIC588=null;
 18831  2660
         Token char_literal589=null;
 18832  2660
         Token char_literal591=null;
 18833  2660
         SparqlParser.expression_return e1 =null;
 18834  532
 
 18835  2660
         SparqlParser.expression_return e2 =null;
 18836  532
 
 18837  2660
         SparqlParser.expression_return e3 =null;
 18838  532
 
 18839  2660
         SparqlParser.expression_return expression391 =null;
 18840  532
 
 18841  2660
         SparqlParser.expression_return expression395 =null;
 18842  532
 
 18843  2660
         SparqlParser.expression_return expression399 =null;
 18844  532
 
 18845  2660
         SparqlParser.expression_return expression401 =null;
 18846  532
 
 18847  2660
         SparqlParser.expression_return expression405 =null;
 18848  532
 
 18849  2660
         SparqlParser.var_return var409 =null;
 18850  532
 
 18851  2660
         SparqlParser.expression_return expression413 =null;
 18852  532
 
 18853  2660
         SparqlParser.expression_return expression417 =null;
 18854  532
 
 18855  2660
         SparqlParser.expression_return expression421 =null;
 18856  532
 
 18857  2660
         SparqlParser.nil_return nil424 =null;
 18858  532
 
 18859  2660
         SparqlParser.nil_return nil426 =null;
 18860  532
 
 18861  2660
         SparqlParser.expression_return expression429 =null;
 18862  532
 
 18863  2660
         SparqlParser.expression_return expression433 =null;
 18864  532
 
 18865  2660
         SparqlParser.expression_return expression437 =null;
 18866  532
 
 18867  2660
         SparqlParser.expression_return expression441 =null;
 18868  532
 
 18869  2660
         SparqlParser.expressionList_return expressionList444 =null;
 18870  532
 
 18871  2660
         SparqlParser.subStringExpression_return subStringExpression445 =null;
 18872  532
 
 18873  2660
         SparqlParser.strReplaceExpression_return strReplaceExpression446 =null;
 18874  532
 
 18875  2660
         SparqlParser.expression_return expression449 =null;
 18876  532
 
 18877  2660
         SparqlParser.expression_return expression453 =null;
 18878  532
 
 18879  2660
         SparqlParser.expression_return expression457 =null;
 18880  532
 
 18881  2660
         SparqlParser.expression_return expression461 =null;
 18882  532
 
 18883  2660
         SparqlParser.expression_return expression465 =null;
 18884  532
 
 18885  2660
         SparqlParser.expression_return expression467 =null;
 18886  532
 
 18887  2660
         SparqlParser.expression_return expression471 =null;
 18888  532
 
 18889  2660
         SparqlParser.expression_return expression473 =null;
 18890  532
 
 18891  2660
         SparqlParser.expression_return expression477 =null;
 18892  532
 
 18893  2660
         SparqlParser.expression_return expression479 =null;
 18894  532
 
 18895  2660
         SparqlParser.expression_return expression483 =null;
 18896  532
 
 18897  2660
         SparqlParser.expression_return expression485 =null;
 18898  532
 
 18899  2660
         SparqlParser.expression_return expression489 =null;
 18900  532
 
 18901  2660
         SparqlParser.expression_return expression491 =null;
 18902  532
 
 18903  2660
         SparqlParser.expression_return expression495 =null;
 18904  532
 
 18905  2660
         SparqlParser.expression_return expression499 =null;
 18906  532
 
 18907  2660
         SparqlParser.expression_return expression503 =null;
 18908  532
 
 18909  2660
         SparqlParser.expression_return expression507 =null;
 18910  532
 
 18911  2660
         SparqlParser.expression_return expression511 =null;
 18912  532
 
 18913  2660
         SparqlParser.expression_return expression515 =null;
 18914  532
 
 18915  2660
         SparqlParser.expression_return expression519 =null;
 18916  532
 
 18917  2660
         SparqlParser.expression_return expression523 =null;
 18918  532
 
 18919  2660
         SparqlParser.nil_return nil526 =null;
 18920  532
 
 18921  2660
         SparqlParser.expression_return expression529 =null;
 18922  532
 
 18923  2660
         SparqlParser.expression_return expression533 =null;
 18924  532
 
 18925  2660
         SparqlParser.expression_return expression537 =null;
 18926  532
 
 18927  2660
         SparqlParser.expression_return expression541 =null;
 18928  532
 
 18929  2660
         SparqlParser.expression_return expression545 =null;
 18930  532
 
 18931  2660
         SparqlParser.expressionList_return expressionList548 =null;
 18932  532
 
 18933  2660
         SparqlParser.expression_return expression556 =null;
 18934  532
 
 18935  2660
         SparqlParser.expression_return expression558 =null;
 18936  532
 
 18937  2660
         SparqlParser.expression_return expression562 =null;
 18938  532
 
 18939  2660
         SparqlParser.expression_return expression564 =null;
 18940  532
 
 18941  2660
         SparqlParser.expression_return expression568 =null;
 18942  532
 
 18943  2660
         SparqlParser.expression_return expression570 =null;
 18944  532
 
 18945  2660
         SparqlParser.expression_return expression574 =null;
 18946  532
 
 18947  2660
         SparqlParser.expression_return expression578 =null;
 18948  532
 
 18949  2660
         SparqlParser.expression_return expression582 =null;
 18950  532
 
 18951  2660
         SparqlParser.expression_return expression586 =null;
 18952  532
 
 18953  2660
         SparqlParser.expression_return expression590 =null;
 18954  532
 
 18955  2660
         SparqlParser.regexExpression_return regexExpression592 =null;
 18956  532
 
 18957  2660
         SparqlParser.existsFunction_return existsFunction593 =null;
 18958  532
 
 18959  2660
         SparqlParser.notExistsFunction_return notExistsFunction594 =null;
 18960  532
 
 18961  532
 
 18962  2660
         Object STR389_tree=null;
 18963  2660
         Object char_literal390_tree=null;
 18964  2660
         Object char_literal392_tree=null;
 18965  2660
         Object LANG393_tree=null;
 18966  2128
         Object char_literal394_tree=null;
 18967  2128
         Object char_literal396_tree=null;
 18968  2660
         Object LANGMATCHES397_tree=null;
 18969  2660
         Object char_literal398_tree=null;
 18970  2128
         Object char_literal400_tree=null;
 18971  2128
         Object char_literal402_tree=null;
 18972  2164
         Object DATATYPE403_tree=null;
 18973  2128
         Object char_literal404_tree=null;
 18974  2164
         Object char_literal406_tree=null;
 18975  2128
         Object BOUND407_tree=null;
 18976  2128
         Object char_literal408_tree=null;
 18977  2168
         Object char_literal410_tree=null;
 18978  2128
         Object IRI411_tree=null;
 18979  2168
         Object char_literal412_tree=null;
 18980  2128
         Object char_literal414_tree=null;
 18981  2128
         Object URI415_tree=null;
 18982  2158
         Object char_literal416_tree=null;
 18983  2128
         Object char_literal418_tree=null;
 18984  2158
         Object BNODE419_tree=null;
 18985  2128
         Object char_literal420_tree=null;
 18986  2128
         Object char_literal422_tree=null;
 18987  2228
         Object BNODE423_tree=null;
 18988  2128
         Object RAND425_tree=null;
 18989  2228
         Object ABS427_tree=null;
 18990  2128
         Object char_literal428_tree=null;
 18991  2128
         Object char_literal430_tree=null;
 18992  2158
         Object CEIL431_tree=null;
 18993  2128
         Object char_literal432_tree=null;
 18994  2158
         Object char_literal434_tree=null;
 18995  2128
         Object FLOOR435_tree=null;
 18996  2128
         Object char_literal436_tree=null;
 18997  2130
         Object char_literal438_tree=null;
 18998  2128
         Object ROUND439_tree=null;
 18999  2130
         Object char_literal440_tree=null;
 19000  2128
         Object char_literal442_tree=null;
 19001  2128
         Object CONCAT443_tree=null;
 19002  2130
         Object STRLEN447_tree=null;
 19003  2128
         Object char_literal448_tree=null;
 19004  2130
         Object char_literal450_tree=null;
 19005  2128
         Object UCASE451_tree=null;
 19006  2128
         Object char_literal452_tree=null;
 19007  2136
         Object char_literal454_tree=null;
 19008  2128
         Object LCASE455_tree=null;
 19009  2128
         Object char_literal456_tree=null;
 19010  2136
         Object char_literal458_tree=null;
 19011  2128
         Object ENCODE_FOR_URI459_tree=null;
 19012  2128
         Object char_literal460_tree=null;
 19013  2132
         Object char_literal462_tree=null;
 19014  2128
         Object CONTAINS463_tree=null;
 19015  2132
         Object char_literal464_tree=null;
 19016  2128
         Object char_literal466_tree=null;
 19017  2128
         Object char_literal468_tree=null;
 19018  2128
         Object STRSTARTS469_tree=null;
 19019  2128
         Object char_literal470_tree=null;
 19020  2128
         Object char_literal472_tree=null;
 19021  2128
         Object char_literal474_tree=null;
 19022  2128
         Object STRENDS475_tree=null;
 19023  2128
         Object char_literal476_tree=null;
 19024  2128
         Object char_literal478_tree=null;
 19025  2128
         Object char_literal480_tree=null;
 19026  2128
         Object STRBEFORE481_tree=null;
 19027  2128
         Object char_literal482_tree=null;
 19028  2128
         Object char_literal484_tree=null;
 19029  2128
         Object char_literal486_tree=null;
 19030  2128
         Object STRAFTER487_tree=null;
 19031  2128
         Object char_literal488_tree=null;
 19032  2128
         Object char_literal490_tree=null;
 19033  2128
         Object char_literal492_tree=null;
 19034  2128
         Object YEAR493_tree=null;
 19035  2128
         Object char_literal494_tree=null;
 19036  2128
         Object char_literal496_tree=null;
 19037  2128
         Object MONTH497_tree=null;
 19038  2128
         Object char_literal498_tree=null;
 19039  2128
         Object char_literal500_tree=null;
 19040  2128
         Object DAY501_tree=null;
 19041  2128
         Object char_literal502_tree=null;
 19042  2128
         Object char_literal504_tree=null;
 19043  2128
         Object HOURS505_tree=null;
 19044  2128
         Object char_literal506_tree=null;
 19045  2128
         Object char_literal508_tree=null;
 19046  2128
         Object MINUTES509_tree=null;
 19047  2128
         Object char_literal510_tree=null;
 19048  2128
         Object char_literal512_tree=null;
 19049  2128
         Object SECONDS513_tree=null;
 19050  2128
         Object char_literal514_tree=null;
 19051  2128
         Object char_literal516_tree=null;
 19052  2128
         Object TIMEZONE517_tree=null;
 19053  2128
         Object char_literal518_tree=null;
 19054  2128
         Object char_literal520_tree=null;
 19055  2128
         Object TZ521_tree=null;
 19056  2128
         Object char_literal522_tree=null;
 19057  2128
         Object char_literal524_tree=null;
 19058  2128
         Object NOW525_tree=null;
 19059  2128
         Object MD5527_tree=null;
 19060  2128
         Object char_literal528_tree=null;
 19061  2128
         Object char_literal530_tree=null;
 19062  2128
         Object SHA1531_tree=null;
 19063  2128
         Object char_literal532_tree=null;
 19064  2128
         Object char_literal534_tree=null;
 19065  2128
         Object SHA256535_tree=null;
 19066  2128
         Object char_literal536_tree=null;
 19067  2128
         Object char_literal538_tree=null;
 19068  2128
         Object SHA384539_tree=null;
 19069  2128
         Object char_literal540_tree=null;
 19070  2128
         Object char_literal542_tree=null;
 19071  2128
         Object SHA512543_tree=null;
 19072  2128
         Object char_literal544_tree=null;
 19073  2128
         Object char_literal546_tree=null;
 19074  2128
         Object COALESCE547_tree=null;
 19075  2128
         Object IF549_tree=null;
 19076  2128
         Object char_literal550_tree=null;
 19077  2128
         Object char_literal551_tree=null;
 19078  2128
         Object char_literal552_tree=null;
 19079  2128
         Object char_literal553_tree=null;
 19080  2128
         Object STRLANG554_tree=null;
 19081  2128
         Object char_literal555_tree=null;
 19082  2128
         Object char_literal557_tree=null;
 19083  2128
         Object char_literal559_tree=null;
 19084  2128
         Object STRDT560_tree=null;
 19085  2128
         Object char_literal561_tree=null;
 19086  2128
         Object char_literal563_tree=null;
 19087  2128
         Object char_literal565_tree=null;
 19088  2128
         Object SAMETERM566_tree=null;
 19089  2128
         Object char_literal567_tree=null;
 19090  2128
         Object char_literal569_tree=null;
 19091  2128
         Object char_literal571_tree=null;
 19092  2128
         Object ISIRI572_tree=null;
 19093  2128
         Object char_literal573_tree=null;
 19094  2128
         Object char_literal575_tree=null;
 19095  2128
         Object ISURI576_tree=null;
 19096  2128
         Object char_literal577_tree=null;
 19097  2128
         Object char_literal579_tree=null;
 19098  2128
         Object ISBLANK580_tree=null;
 19099  2128
         Object char_literal581_tree=null;
 19100  2132
         Object char_literal583_tree=null;
 19101  2128
         Object ISLITERAL584_tree=null;
 19102  2132
         Object char_literal585_tree=null;
 19103  2128
         Object char_literal587_tree=null;
 19104  2128
         Object ISNUMERIC588_tree=null;
 19105  2128
         Object char_literal589_tree=null;
 19106  2128
         Object char_literal591_tree=null;
 19107  2128
         RewriteRuleTokenStream stream_SHA256=new RewriteRuleTokenStream(adaptor,"token SHA256");
 19108  2128
         RewriteRuleTokenStream stream_YEAR=new RewriteRuleTokenStream(adaptor,"token YEAR");
 19109  2128
         RewriteRuleTokenStream stream_TIMEZONE=new RewriteRuleTokenStream(adaptor,"token TIMEZONE");
 19110  2128
         RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
 19111  2128
         RewriteRuleTokenStream stream_STRENDS=new RewriteRuleTokenStream(adaptor,"token STRENDS");
 19112  2136
         RewriteRuleTokenStream stream_LCASE=new RewriteRuleTokenStream(adaptor,"token LCASE");
 19113  2128
         RewriteRuleTokenStream stream_BNODE=new RewriteRuleTokenStream(adaptor,"token BNODE");
 19114  2128
         RewriteRuleTokenStream stream_SHA512=new RewriteRuleTokenStream(adaptor,"token SHA512");
 19115  2128
         RewriteRuleTokenStream stream_SECONDS=new RewriteRuleTokenStream(adaptor,"token SECONDS");
 19116  2128
         RewriteRuleTokenStream stream_NOW=new RewriteRuleTokenStream(adaptor,"token NOW");
 19117  2128
         RewriteRuleTokenStream stream_DAY=new RewriteRuleTokenStream(adaptor,"token DAY");
 19118  2128
         RewriteRuleTokenStream stream_STRAFTER=new RewriteRuleTokenStream(adaptor,"token STRAFTER");
 19119  2128
         RewriteRuleTokenStream stream_STRLEN=new RewriteRuleTokenStream(adaptor,"token STRLEN");
 19120  2128
         RewriteRuleTokenStream stream_MONTH=new RewriteRuleTokenStream(adaptor,"token MONTH");
 19121  2128
         RewriteRuleTokenStream stream_ENCODE_FOR_URI=new RewriteRuleTokenStream(adaptor,"token ENCODE_FOR_URI");
 19122  2136
         RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
 19123  2128
         RewriteRuleTokenStream stream_ISURI=new RewriteRuleTokenStream(adaptor,"token ISURI");
 19124  2128
         RewriteRuleTokenStream stream_STR=new RewriteRuleTokenStream(adaptor,"token STR");
 19125  2130
         RewriteRuleTokenStream stream_STRDT=new RewriteRuleTokenStream(adaptor,"token STRDT");
 19126  2128
         RewriteRuleTokenStream stream_ISLITERAL=new RewriteRuleTokenStream(adaptor,"token ISLITERAL");
 19127  2130
         RewriteRuleTokenStream stream_SAMETERM=new RewriteRuleTokenStream(adaptor,"token SAMETERM");
 19128  2128
         RewriteRuleTokenStream stream_MD5=new RewriteRuleTokenStream(adaptor,"token MD5");
 19129  2128
         RewriteRuleTokenStream stream_RAND=new RewriteRuleTokenStream(adaptor,"token RAND");
 19130  2130
         RewriteRuleTokenStream stream_IRI=new RewriteRuleTokenStream(adaptor,"token IRI");
 19131  2128
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 19132  2130
         RewriteRuleTokenStream stream_LANGMATCHES=new RewriteRuleTokenStream(adaptor,"token LANGMATCHES");
 19133  2128
         RewriteRuleTokenStream stream_TZ=new RewriteRuleTokenStream(adaptor,"token TZ");
 19134  2128
         RewriteRuleTokenStream stream_STRLANG=new RewriteRuleTokenStream(adaptor,"token STRLANG");
 19135  2130
         RewriteRuleTokenStream stream_BOUND=new RewriteRuleTokenStream(adaptor,"token BOUND");
 19136  2128
         RewriteRuleTokenStream stream_ISIRI=new RewriteRuleTokenStream(adaptor,"token ISIRI");
 19137  2130
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 19138  2128
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 19139  2128
         RewriteRuleTokenStream stream_COALESCE=new RewriteRuleTokenStream(adaptor,"token COALESCE");
 19140  2130
         RewriteRuleTokenStream stream_ISNUMERIC=new RewriteRuleTokenStream(adaptor,"token ISNUMERIC");
 19141  2128
         RewriteRuleTokenStream stream_CONCAT=new RewriteRuleTokenStream(adaptor,"token CONCAT");
 19142  2130
         RewriteRuleTokenStream stream_STRSTARTS=new RewriteRuleTokenStream(adaptor,"token STRSTARTS");
 19143  2128
         RewriteRuleTokenStream stream_STRBEFORE=new RewriteRuleTokenStream(adaptor,"token STRBEFORE");
 19144  2128
         RewriteRuleTokenStream stream_SHA1=new RewriteRuleTokenStream(adaptor,"token SHA1");
 19145  2130
         RewriteRuleTokenStream stream_FLOOR=new RewriteRuleTokenStream(adaptor,"token FLOOR");
 19146  2128
         RewriteRuleTokenStream stream_ISBLANK=new RewriteRuleTokenStream(adaptor,"token ISBLANK");
 19147  2130
         RewriteRuleTokenStream stream_UCASE=new RewriteRuleTokenStream(adaptor,"token UCASE");
 19148  2128
         RewriteRuleTokenStream stream_URI=new RewriteRuleTokenStream(adaptor,"token URI");
 19149  2128
         RewriteRuleTokenStream stream_ABS=new RewriteRuleTokenStream(adaptor,"token ABS");
 19150  2138
         RewriteRuleTokenStream stream_MINUTES=new RewriteRuleTokenStream(adaptor,"token MINUTES");
 19151  2128
         RewriteRuleTokenStream stream_ROUND=new RewriteRuleTokenStream(adaptor,"token ROUND");
 19152  2138
         RewriteRuleTokenStream stream_CEIL=new RewriteRuleTokenStream(adaptor,"token CEIL");
 19153  2128
         RewriteRuleTokenStream stream_DATATYPE=new RewriteRuleTokenStream(adaptor,"token DATATYPE");
 19154  2128
         RewriteRuleTokenStream stream_SHA384=new RewriteRuleTokenStream(adaptor,"token SHA384");
 19155  2132
         RewriteRuleTokenStream stream_HOURS=new RewriteRuleTokenStream(adaptor,"token HOURS");
 19156  2128
         RewriteRuleTokenStream stream_LANG=new RewriteRuleTokenStream(adaptor,"token LANG");
 19157  2132
         RewriteRuleSubtreeStream stream_existsFunction=new RewriteRuleSubtreeStream(adaptor,"rule existsFunction");
 19158  2128
         RewriteRuleSubtreeStream stream_subStringExpression=new RewriteRuleSubtreeStream(adaptor,"rule subStringExpression");
 19159  2128
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 19160  2134
         RewriteRuleSubtreeStream stream_strReplaceExpression=new RewriteRuleSubtreeStream(adaptor,"rule strReplaceExpression");
 19161  2128
         RewriteRuleSubtreeStream stream_notExistsFunction=new RewriteRuleSubtreeStream(adaptor,"rule notExistsFunction");
 19162  2134
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 19163  2128
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 19164  2128
         RewriteRuleSubtreeStream stream_regexExpression=new RewriteRuleSubtreeStream(adaptor,"rule regexExpression");
 19165  2130
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 19166  
         try {
 19167  2
             // com\\googlecode\\sparkleg\\Sparql.g:573:5: ( STR '(' expression ')' -> ^( STR expression ) | LANG '(' expression ')' -> ^( LANG expression ) | LANGMATCHES '(' expression ',' expression ')' -> ^( LANGMATCHES ( expression )+ ) | DATATYPE '(' expression ')' -> ^( DATATYPE expression ) | BOUND '(' var ')' -> ^( BOUND var ) | IRI '(' expression ')' -> ^( IRI expression ) | URI '(' expression ')' -> ^( URI expression ) | BNODE ( '(' expression ')' ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS '(' expression ')' -> ^( ABS expression ) | CEIL '(' expression ')' -> ^( CEIL expression ) | FLOOR '(' expression ')' -> ^( FLOOR expression ) | ROUND '(' expression ')' -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | strReplaceExpression -> strReplaceExpression | STRLEN '(' expression ')' -> ^( STRLEN expression ) | UCASE '(' expression ')' -> ^( UCASE expression ) | LCASE '(' expression ')' -> ^( LCASE expression ) | ENCODE_FOR_URI '(' expression ')' -> ^( ENCODE_FOR_URI expression ) | CONTAINS '(' expression ',' expression ')' -> ^( CONTAINS expression expression ) | STRSTARTS '(' expression ',' expression ')' -> ^( STRSTARTS expression expression ) | STRENDS '(' expression ',' expression ')' -> ^( STRENDS expression expression ) | STRBEFORE '(' expression ',' expression ')' -> ^( STRBEFORE expression expression ) | STRAFTER '(' expression ',' expression ')' -> ^( STRAFTER expression expression ) | YEAR '(' expression ')' -> ^( YEAR expression ) | MONTH '(' expression ')' -> ^( MONTH expression ) | DAY '(' expression ')' -> ^( DAY expression ) | HOURS '(' expression ')' -> ^( HOURS expression ) | MINUTES '(' expression ')' -> ^( MINUTES expression ) | SECONDS '(' expression ')' -> ^( SECONDS expression ) | TIMEZONE '(' expression ')' -> ^( TIMEZONE expression ) | TZ '(' expression ')' -> ^( TZ expression ) | NOW nil -> NOW | MD5 '(' expression ')' -> ^( MD5 expression ) | SHA1 '(' expression ')' -> ^( SHA1 expression ) | SHA256 '(' expression ')' -> ^( SHA256 expression ) | SHA384 '(' expression ')' -> ^( SHA384 expression ) | SHA512 '(' expression ')' -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF '(' e1= expression ',' e2= expression ',' e3= expression ')' -> ^( IF $e1 $e2 $e3) | STRLANG '(' expression ',' expression ')' -> ^( STRLANG expression expression ) | STRDT '(' expression ',' expression ')' -> ^( STRDT expression expression ) | SAMETERM '(' expression ',' expression ')' -> ^( SAMETERM expression expression ) | ISIRI '(' expression ')' -> ^( ISIRI expression ) | ISURI '(' expression ')' -> ^( ISURI expression ) | ISBLANK '(' expression ')' -> ^( ISBLANK expression ) | ISLITERAL '(' expression ')' -> ^( ISLITERAL expression ) | ISNUMERIC '(' expression ')' -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction )
 19168  2128
             int alt124=53;
 19169  2128
             switch ( input.LA(1) ) {
 19170  2
             case STR:
 19171  
                 {
 19172  146
                 alt124=1;
 19173  
                 }
 19174  144
                 break;
 19175  2
             case LANG:
 19176  
                 {
 19177  162
                 alt124=2;
 19178  
                 }
 19179  160
                 break;
 19180  2
             case LANGMATCHES:
 19181  
                 {
 19182  122
                 alt124=3;
 19183  
                 }
 19184  120
                 break;
 19185  2
             case DATATYPE:
 19186  
                 {
 19187  402
                 alt124=4;
 19188  
                 }
 19189  400
                 break;
 19190  2
             case BOUND:
 19191  
                 {
 19192  122
                 alt124=5;
 19193  
                 }
 19194  120
                 break;
 19195  2
             case IRI:
 19196  
                 {
 19197  10
                 alt124=6;
 19198  
                 }
 19199  8
                 break;
 19200  2
             case URI:
 19201  
                 {
 19202  10
                 alt124=7;
 19203  
                 }
 19204  8
                 break;
 19205  2
             case BNODE:
 19206  
                 {
 19207  34
                 switch ( input.LA(2) ) {
 19208  
                 case 209:
 19209  
                     {
 19210  34
                     switch ( input.LA(3) ) {
 19211  
                     case 210:
 19212  2
                         {
 19213  16
                         alt124=9;
 19214  
                         }
 19215  18
                         break;
 19216  
                     case ABS:
 19217  2
                     case AVG:
 19218  
                     case BNODE:
 19219  
                     case BOUND:
 19220  2
                     case CEIL:
 19221  
                     case COALESCE:
 19222  2
                     case CONCAT:
 19223  
                     case CONTAINS:
 19224  
                     case COUNT:
 19225  2
                     case DATATYPE:
 19226  
                     case DAY:
 19227  2
                     case DECIMAL:
 19228  
                     case DECIMAL_NEGATIVE:
 19229  
                     case DECIMAL_POSITIVE:
 19230  2
                     case DOUBLE:
 19231  
                     case DOUBLE_NEGATIVE:
 19232  2
                     case DOUBLE_POSITIVE:
 19233  
                     case ENCODE_FOR_URI:
 19234  
                     case EXISTS:
 19235  2
                     case FALSE:
 19236  
                     case FLOOR:
 19237  2
                     case GROUP_CONCAT:
 19238  
                     case HOURS:
 19239  
                     case IF:
 19240  2
                     case INTEGER:
 19241  
                     case INTEGER_NEGATIVE:
 19242  2
                     case INTEGER_POSITIVE:
 19243  
                     case IRI:
 19244  
                     case IRI_REF:
 19245  2
                     case ISBLANK:
 19246  
                     case ISIRI:
 19247  2
                     case ISLITERAL:
 19248  
                     case ISNUMERIC:
 19249  
                     case ISURI:
 19250  2
                     case LANG:
 19251  
                     case LANGMATCHES:
 19252  2
                     case LCASE:
 19253  
                     case MAX:
 19254  
                     case MD5:
 19255  4
                     case MIN:
 19256  
                     case MINUS:
 19257  4
                     case MINUTES:
 19258  
                     case MONTH:
 19259  
                     case NEGATION:
 19260  4
                     case NOT:
 19261  
                     case NOW:
 19262  4
                     case PLUS:
 19263  
                     case PNAME_LN:
 19264  
                     case PNAME_NS:
 19265  4
                     case RAND:
 19266  
                     case REGEX:
 19267  4
                     case REPLACE:
 19268  
                     case ROUND:
 19269  
                     case SAMETERM:
 19270  4
                     case SAMPLE:
 19271  
                     case SECONDS:
 19272  4
                     case SHA1:
 19273  
                     case SHA256:
 19274  
                     case SHA384:
 19275  4
                     case SHA512:
 19276  
                     case STR:
 19277  4
                     case STRAFTER:
 19278  
                     case STRBEFORE:
 19279  
                     case STRDT:
 19280  12
                     case STRENDS:
 19281  
                     case STRING_LITERAL1:
 19282  12
                     case STRING_LITERAL2:
 19283  
                     case STRING_LITERAL_LONG1:
 19284  
                     case STRING_LITERAL_LONG2:
 19285  6
                     case STRLANG:
 19286  
                     case STRLEN:
 19287  6
                     case STRSTARTS:
 19288  
                     case SUBSTR:
 19289  
                     case SUM:
 19290  6
                     case TIMEZONE:
 19291  
                     case TRUE:
 19292  6
                     case TZ:
 19293  
                     case UCASE:
 19294  
                     case URI:
 19295  6
                     case VAR1:
 19296  
                     case VAR2:
 19297  6
                     case YEAR:
 19298  
                     case 209:
 19299  
                         {
 19300  46
                         alt124=8;
 19301  
                         }
 19302  46
                         break;
 19303  
                     default:
 19304  0
                         NoViableAltException nvae =
 19305  8
                             new NoViableAltException("", 124, 53, input);
 19306  
 
 19307  8
                         throw nvae;
 19308  
 
 19309  
                     }
 19310  2
 
 19311  
                     }
 19312  34
                     break;
 19313  
                 default:
 19314  0
                     NoViableAltException nvae =
 19315  8
                         new NoViableAltException("", 124, 8, input);
 19316  
 
 19317  8
                     throw nvae;
 19318  
 
 19319  
                 }
 19320  8
 
 19321  
                 }
 19322  40
                 break;
 19323  
             case RAND:
 19324  
                 {
 19325  12
                 alt124=10;
 19326  
                 }
 19327  12
                 break;
 19328  
             case ABS:
 19329  
                 {
 19330  50
                 alt124=11;
 19331  
                 }
 19332  50
                 break;
 19333  
             case CEIL:
 19334  
                 {
 19335  28
                 alt124=12;
 19336  
                 }
 19337  28
                 break;
 19338  
             case FLOOR:
 19339  
                 {
 19340  54
                 alt124=13;
 19341  
                 }
 19342  54
                 break;
 19343  
             case ROUND:
 19344  
                 {
 19345  8
                 alt124=14;
 19346  
                 }
 19347  8
                 break;
 19348  
             case CONCAT:
 19349  
                 {
 19350  40
                 alt124=15;
 19351  532
                 }
 19352  40
                 break;
 19353  
             case SUBSTR:
 19354  
                 {
 19355  52
                 alt124=16;
 19356  36
                 }
 19357  16
                 break;
 19358  
             case REPLACE:
 19359  36
                 {
 19360  60
                 alt124=17;
 19361  
                 }
 19362  24
                 break;
 19363  36
             case STRLEN:
 19364  36
                 {
 19365  8
                 alt124=18;
 19366  36
                 }
 19367  8
                 break;
 19368  36
             case UCASE:
 19369  
                 {
 19370  44
                 alt124=19;
 19371  36
                 }
 19372  8
                 break;
 19373  
             case LCASE:
 19374  
                 {
 19375  8
                 alt124=20;
 19376  
                 }
 19377  8
                 break;
 19378  
             case ENCODE_FOR_URI:
 19379  
                 {
 19380  8
                 alt124=21;
 19381  36
                 }
 19382  44
                 break;
 19383  
             case CONTAINS:
 19384  36
                 {
 19385  8
                 alt124=22;
 19386  
                 }
 19387  8
                 break;
 19388  
             case STRSTARTS:
 19389  36
                 {
 19390  44
                 alt124=23;
 19391  
                 }
 19392  8
                 break;
 19393  
             case STRENDS:
 19394  36
                 {
 19395  8
                 alt124=24;
 19396  36
                 }
 19397  8
                 break;
 19398  
             case STRBEFORE:
 19399  
                 {
 19400  8
                 alt124=25;
 19401  
                 }
 19402  44
                 break;
 19403  
             case STRAFTER:
 19404  
                 {
 19405  44
                 alt124=26;
 19406  
                 }
 19407  8
                 break;
 19408  
             case YEAR:
 19409  40
                 {
 19410  48
                 alt124=27;
 19411  
                 }
 19412  8
                 break;
 19413  40
             case MONTH:
 19414  40
                 {
 19415  8
                 alt124=28;
 19416  
                 }
 19417  48
                 break;
 19418  40
             case DAY:
 19419  
                 {
 19420  48
                 alt124=29;
 19421  
                 }
 19422  48
                 break;
 19423  
             case HOURS:
 19424  40
                 {
 19425  48
                 alt124=30;
 19426  
                 }
 19427  8
                 break;
 19428  
             case MINUTES:
 19429  
                 {
 19430  8
                 alt124=31;
 19431  
                 }
 19432  8
                 break;
 19433  
             case SECONDS:
 19434  
                 {
 19435  48
                 alt124=32;
 19436  40
                 }
 19437  8
                 break;
 19438  40
             case TIMEZONE:
 19439  
                 {
 19440  8
                 alt124=33;
 19441  
                 }
 19442  8
                 break;
 19443  40
             case TZ:
 19444  40
                 {
 19445  8
                 alt124=34;
 19446  
                 }
 19447  8
                 break;
 19448  40
             case NOW:
 19449  
                 {
 19450  48
                 alt124=35;
 19451  
                 }
 19452  8
                 break;
 19453  
             case MD5:
 19454  
                 {
 19455  16
                 alt124=36;
 19456  40
                 }
 19457  16
                 break;
 19458  
             case SHA1:
 19459  40
                 {
 19460  16
                 alt124=37;
 19461  
                 }
 19462  16
                 break;
 19463  30
             case SHA256:
 19464  30
                 {
 19465  16
                 alt124=38;
 19466  
                 }
 19467  46
                 break;
 19468  30
             case SHA384:
 19469  
                 {
 19470  16
                 alt124=39;
 19471  30
                 }
 19472  46
                 break;
 19473  
             case SHA512:
 19474  30
                 {
 19475  16
                 alt124=40;
 19476  30
                 }
 19477  16
                 break;
 19478  30
             case COALESCE:
 19479  30
                 {
 19480  48
                 alt124=41;
 19481  
                 }
 19482  78
                 break;
 19483  30
             case IF:
 19484  
                 {
 19485  54
                 alt124=42;
 19486  
                 }
 19487  54
                 break;
 19488  
             case STRLANG:
 19489  30
                 {
 19490  54
                 alt124=43;
 19491  
                 }
 19492  24
                 break;
 19493  
             case STRDT:
 19494  
                 {
 19495  24
                 alt124=44;
 19496  
                 }
 19497  24
                 break;
 19498  
             case SAMETERM:
 19499  
                 {
 19500  150
                 alt124=45;
 19501  30
                 }
 19502  120
                 break;
 19503  30
             case ISIRI:
 19504  
                 {
 19505  32
                 alt124=46;
 19506  
                 }
 19507  32
                 break;
 19508  30
             case ISURI:
 19509  30
                 {
 19510  8
                 alt124=47;
 19511  
                 }
 19512  8
                 break;
 19513  30
             case ISBLANK:
 19514  
                 {
 19515  32
                 alt124=48;
 19516  90
                 }
 19517  92
                 break;
 19518  
             case ISLITERAL:
 19519  
                 {
 19520  62
                 alt124=49;
 19521  
                 }
 19522  62
                 break;
 19523  
             case ISNUMERIC:
 19524  
                 {
 19525  16
                 alt124=50;
 19526  
                 }
 19527  16
                 break;
 19528  30
             case REGEX:
 19529  
                 {
 19530  168
                 alt124=51;
 19531  30
                 }
 19532  168
                 break;
 19533  
             case EXISTS:
 19534  
                 {
 19535  180
                 alt124=52;
 19536  100
                 }
 19537  80
                 break;
 19538  
             case NOT:
 19539  100
                 {
 19540  284
                 alt124=53;
 19541  
                 }
 19542  184
                 break;
 19543  100
             default:
 19544  100
                 NoViableAltException nvae =
 19545  
                     new NoViableAltException("", 124, 0, input);
 19546  100
 
 19547  0
                 throw nvae;
 19548  100
 
 19549  
             }
 19550  100
 
 19551  2228
             switch (alt124) {
 19552  
                 case 1 :
 19553  
                     // com\\googlecode\\sparkleg\\Sparql.g:573:7: STR '(' expression ')'
 19554  
                     {
 19555  144
                     STR389=(Token)match(input,STR,FOLLOW_STR_in_builtInCall5275);  
 19556  144
                     stream_STR.add(STR389);
 19557  
 
 19558  
 
 19559  144
                     char_literal390=(Token)match(input,209,FOLLOW_209_in_builtInCall5277);  
 19560  144
                     stream_209.add(char_literal390);
 19561  100
 
 19562  100
 
 19563  144
                     pushFollow(FOLLOW_expression_in_builtInCall5279);
 19564  244
                     expression391=expression();
 19565  
 
 19566  144
                     state._fsp--;
 19567  
 
 19568  144
                     stream_expression.add(expression391.getTree());
 19569  100
 
 19570  244
                     char_literal392=(Token)match(input,210,FOLLOW_210_in_builtInCall5281);  
 19571  144
                     stream_210.add(char_literal392);
 19572  
 
 19573  
 
 19574  100
                     // AST REWRITE
 19575  
                     // elements: STR, expression
 19576  100
                     // token labels: 
 19577  
                     // rule labels: retval
 19578  
                     // token list labels: 
 19579  
                     // rule list labels: 
 19580  
                     // wildcard labels: 
 19581  144
                     retval.tree = root_0;
 19582  244
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19583  
 
 19584  144
                     root_0 = (Object)adaptor.nil();
 19585  100
                     // 573:30: -> ^( STR expression )
 19586  
                     {
 19587  
                         // com\\googlecode\\sparkleg\\Sparql.g:573:33: ^( STR expression )
 19588  
                         {
 19589  174
                         Object root_1 = (Object)adaptor.nil();
 19590  174
                         root_1 = (Object)adaptor.becomeRoot(
 19591  
                         stream_STR.nextNode()
 19592  
                         , root_1);
 19593  30
 
 19594  174
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19595  
 
 19596  144
                         adaptor.addChild(root_0, root_1);
 19597  30
                         }
 19598  30
 
 19599  
                     }
 19600  30
 
 19601  
 
 19602  174
                     retval.tree = root_0;
 19603  
 
 19604  30
                     }
 19605  174
                     break;
 19606  
                 case 2 :
 19607  
                     // com\\googlecode\\sparkleg\\Sparql.g:574:7: LANG '(' expression ')'
 19608  
                     {
 19609  160
                     LANG393=(Token)match(input,LANG,FOLLOW_LANG_in_builtInCall5297);  
 19610  160
                     stream_LANG.add(LANG393);
 19611  
 
 19612  
 
 19613  160
                     char_literal394=(Token)match(input,209,FOLLOW_209_in_builtInCall5299);  
 19614  160
                     stream_209.add(char_literal394);
 19615  30
 
 19616  30
 
 19617  160
                     pushFollow(FOLLOW_expression_in_builtInCall5301);
 19618  190
                     expression395=expression();
 19619  
 
 19620  160
                     state._fsp--;
 19621  
 
 19622  160
                     stream_expression.add(expression395.getTree());
 19623  30
 
 19624  190
                     char_literal396=(Token)match(input,210,FOLLOW_210_in_builtInCall5303);  
 19625  160
                     stream_210.add(char_literal396);
 19626  
 
 19627  
 
 19628  30
                     // AST REWRITE
 19629  
                     // elements: LANG, expression
 19630  30
                     // token labels: 
 19631  
                     // rule labels: retval
 19632  
                     // token list labels: 
 19633  
                     // rule list labels: 
 19634  
                     // wildcard labels: 
 19635  160
                     retval.tree = root_0;
 19636  190
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19637  
 
 19638  160
                     root_0 = (Object)adaptor.nil();
 19639  30
                     // 574:31: -> ^( LANG expression )
 19640  
                     {
 19641  
                         // com\\googlecode\\sparkleg\\Sparql.g:574:34: ^( LANG expression )
 19642  
                         {
 19643  162
                         Object root_1 = (Object)adaptor.nil();
 19644  162
                         root_1 = (Object)adaptor.becomeRoot(
 19645  
                         stream_LANG.nextNode()
 19646  
                         , root_1);
 19647  2
 
 19648  162
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19649  
 
 19650  160
                         adaptor.addChild(root_0, root_1);
 19651  2
                         }
 19652  2
 
 19653  
                     }
 19654  2
 
 19655  
 
 19656  162
                     retval.tree = root_0;
 19657  
 
 19658  2
                     }
 19659  162
                     break;
 19660  
                 case 3 :
 19661  
                     // com\\googlecode\\sparkleg\\Sparql.g:575:7: LANGMATCHES '(' expression ',' expression ')'
 19662  
                     {
 19663  120
                     LANGMATCHES397=(Token)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall5319);  
 19664  120
                     stream_LANGMATCHES.add(LANGMATCHES397);
 19665  
 
 19666  
 
 19667  120
                     char_literal398=(Token)match(input,209,FOLLOW_209_in_builtInCall5321);  
 19668  120
                     stream_209.add(char_literal398);
 19669  2
 
 19670  2
 
 19671  120
                     pushFollow(FOLLOW_expression_in_builtInCall5323);
 19672  122
                     expression399=expression();
 19673  
 
 19674  120
                     state._fsp--;
 19675  
 
 19676  120
                     stream_expression.add(expression399.getTree());
 19677  2
 
 19678  122
                     char_literal400=(Token)match(input,211,FOLLOW_211_in_builtInCall5325);  
 19679  120
                     stream_211.add(char_literal400);
 19680  
 
 19681  
 
 19682  122
                     pushFollow(FOLLOW_expression_in_builtInCall5327);
 19683  120
                     expression401=expression();
 19684  2
 
 19685  120
                     state._fsp--;
 19686  
 
 19687  120
                     stream_expression.add(expression401.getTree());
 19688  
 
 19689  120
                     char_literal402=(Token)match(input,210,FOLLOW_210_in_builtInCall5329);  
 19690  122
                     stream_210.add(char_literal402);
 19691  
 
 19692  
 
 19693  2
                     // AST REWRITE
 19694  
                     // elements: expression, LANGMATCHES
 19695  
                     // token labels: 
 19696  
                     // rule labels: retval
 19697  2
                     // token list labels: 
 19698  2
                     // rule list labels: 
 19699  
                     // wildcard labels: 
 19700  120
                     retval.tree = root_0;
 19701  122
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19702  2
 
 19703  120
                     root_0 = (Object)adaptor.nil();
 19704  
                     // 575:53: -> ^( LANGMATCHES ( expression )+ )
 19705  2
                     {
 19706  2
                         // com\\googlecode\\sparkleg\\Sparql.g:575:56: ^( LANGMATCHES ( expression )+ )
 19707  
                         {
 19708  122
                         Object root_1 = (Object)adaptor.nil();
 19709  120
                         root_1 = (Object)adaptor.becomeRoot(
 19710  2
                         stream_LANGMATCHES.nextNode()
 19711  
                         , root_1);
 19712  2
 
 19713  122
                         if ( !(stream_expression.hasNext()) ) {
 19714  0
                             throw new RewriteEarlyExitException();
 19715  
                         }
 19716  360
                         while ( stream_expression.hasNext() ) {
 19717  240
                             adaptor.addChild(root_1, stream_expression.nextTree());
 19718  
 
 19719  
                         }
 19720  120
                         stream_expression.reset();
 19721  
 
 19722  120
                         adaptor.addChild(root_0, root_1);
 19723  2
                         }
 19724  2
 
 19725  
                     }
 19726  2
 
 19727  
 
 19728  120
                     retval.tree = root_0;
 19729  
 
 19730  
                     }
 19731  122
                     break;
 19732  2
                 case 4 :
 19733  
                     // com\\googlecode\\sparkleg\\Sparql.g:576:7: DATATYPE '(' expression ')'
 19734  
                     {
 19735  400
                     DATATYPE403=(Token)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall5346);  
 19736  402
                     stream_DATATYPE.add(DATATYPE403);
 19737  
 
 19738  2
 
 19739  400
                     char_literal404=(Token)match(input,209,FOLLOW_209_in_builtInCall5348);  
 19740  400
                     stream_209.add(char_literal404);
 19741  
 
 19742  
 
 19743  400
                     pushFollow(FOLLOW_expression_in_builtInCall5350);
 19744  402
                     expression405=expression();
 19745  
 
 19746  400
                     state._fsp--;
 19747  2
 
 19748  400
                     stream_expression.add(expression405.getTree());
 19749  
 
 19750  400
                     char_literal406=(Token)match(input,210,FOLLOW_210_in_builtInCall5352);  
 19751  404
                     stream_210.add(char_literal406);
 19752  4
 
 19753  
 
 19754  
                     // AST REWRITE
 19755  
                     // elements: expression, DATATYPE
 19756  
                     // token labels: 
 19757  
                     // rule labels: retval
 19758  4
                     // token list labels: 
 19759  4
                     // rule list labels: 
 19760  
                     // wildcard labels: 
 19761  400
                     retval.tree = root_0;
 19762  404
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19763  4
 
 19764  400
                     root_0 = (Object)adaptor.nil();
 19765  4
                     // 576:35: -> ^( DATATYPE expression )
 19766  
                     {
 19767  4
                         // com\\googlecode\\sparkleg\\Sparql.g:576:38: ^( DATATYPE expression )
 19768  
                         {
 19769  404
                         Object root_1 = (Object)adaptor.nil();
 19770  404
                         root_1 = (Object)adaptor.becomeRoot(
 19771  
                         stream_DATATYPE.nextNode()
 19772  
                         , root_1);
 19773  
 
 19774  400
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19775  
 
 19776  400
                         adaptor.addChild(root_0, root_1);
 19777  
                         }
 19778  
 
 19779  
                     }
 19780  
 
 19781  
 
 19782  400
                     retval.tree = root_0;
 19783  4
 
 19784  4
                     }
 19785  400
                     break;
 19786  4
                 case 5 :
 19787  
                     // com\\googlecode\\sparkleg\\Sparql.g:577:7: BOUND '(' var ')'
 19788  
                     {
 19789  120
                     BOUND407=(Token)match(input,BOUND,FOLLOW_BOUND_in_builtInCall5368);  
 19790  120
                     stream_BOUND.add(BOUND407);
 19791  4
 
 19792  4
 
 19793  120
                     char_literal408=(Token)match(input,209,FOLLOW_209_in_builtInCall5370);  
 19794  120
                     stream_209.add(char_literal408);
 19795  
 
 19796  4
 
 19797  120
                     pushFollow(FOLLOW_var_in_builtInCall5372);
 19798  124
                     var409=var();
 19799  
 
 19800  120
                     state._fsp--;
 19801  
 
 19802  120
                     stream_var.add(var409.getTree());
 19803  
 
 19804  124
                     char_literal410=(Token)match(input,210,FOLLOW_210_in_builtInCall5374);  
 19805  120
                     stream_210.add(char_literal410);
 19806  
 
 19807  4
 
 19808  
                     // AST REWRITE
 19809  
                     // elements: var, BOUND
 19810  
                     // token labels: 
 19811  4
                     // rule labels: retval
 19812  4
                     // token list labels: 
 19813  
                     // rule list labels: 
 19814  
                     // wildcard labels: 
 19815  124
                     retval.tree = root_0;
 19816  124
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19817  
 
 19818  124
                     root_0 = (Object)adaptor.nil();
 19819  
                     // 577:25: -> ^( BOUND var )
 19820  4
                     {
 19821  
                         // com\\googlecode\\sparkleg\\Sparql.g:577:28: ^( BOUND var )
 19822  
                         {
 19823  120
                         Object root_1 = (Object)adaptor.nil();
 19824  120
                         root_1 = (Object)adaptor.becomeRoot(
 19825  
                         stream_BOUND.nextNode()
 19826  
                         , root_1);
 19827  
 
 19828  120
                         adaptor.addChild(root_1, stream_var.nextTree());
 19829  4
 
 19830  124
                         adaptor.addChild(root_0, root_1);
 19831  
                         }
 19832  4
 
 19833  
                     }
 19834  
 
 19835  4
 
 19836  120
                     retval.tree = root_0;
 19837  
 
 19838  
                     }
 19839  120
                     break;
 19840  
                 case 6 :
 19841  
                     // com\\googlecode\\sparkleg\\Sparql.g:578:7: IRI '(' expression ')'
 19842  4
                     {
 19843  8
                     IRI411=(Token)match(input,IRI,FOLLOW_IRI_in_builtInCall5390);  
 19844  8
                     stream_IRI.add(IRI411);
 19845  4
 
 19846  
 
 19847  8
                     char_literal412=(Token)match(input,209,FOLLOW_209_in_builtInCall5392);  
 19848  8
                     stream_209.add(char_literal412);
 19849  2
 
 19850  2
 
 19851  8
                     pushFollow(FOLLOW_expression_in_builtInCall5394);
 19852  8
                     expression413=expression();
 19853  2
 
 19854  10
                     state._fsp--;
 19855  
 
 19856  10
                     stream_expression.add(expression413.getTree());
 19857  
 
 19858  10
                     char_literal414=(Token)match(input,210,FOLLOW_210_in_builtInCall5396);  
 19859  8
                     stream_210.add(char_literal414);
 19860  
 
 19861  
 
 19862  
                     // AST REWRITE
 19863  
                     // elements: IRI, expression
 19864  
                     // token labels: 
 19865  
                     // rule labels: retval
 19866  
                     // token list labels: 
 19867  2
                     // rule list labels: 
 19868  2
                     // wildcard labels: 
 19869  8
                     retval.tree = root_0;
 19870  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19871  
 
 19872  8
                     root_0 = (Object)adaptor.nil();
 19873  2
                     // 578:30: -> ^( IRI expression )
 19874  
                     {
 19875  
                         // com\\googlecode\\sparkleg\\Sparql.g:578:33: ^( IRI expression )
 19876  
                         {
 19877  8
                         Object root_1 = (Object)adaptor.nil();
 19878  8
                         root_1 = (Object)adaptor.becomeRoot(
 19879  
                         stream_IRI.nextNode()
 19880  2
                         , root_1);
 19881  
 
 19882  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19883  2
 
 19884  8
                         adaptor.addChild(root_0, root_1);
 19885  
                         }
 19886  
 
 19887  2
                     }
 19888  2
 
 19889  
 
 19890  8
                     retval.tree = root_0;
 19891  2
 
 19892  2
                     }
 19893  8
                     break;
 19894  
                 case 7 :
 19895  2
                     // com\\googlecode\\sparkleg\\Sparql.g:579:7: URI '(' expression ')'
 19896  2
                     {
 19897  8
                     URI415=(Token)match(input,URI,FOLLOW_URI_in_builtInCall5412);  
 19898  10
                     stream_URI.add(URI415);
 19899  
 
 19900  2
 
 19901  8
                     char_literal416=(Token)match(input,209,FOLLOW_209_in_builtInCall5414);  
 19902  10
                     stream_209.add(char_literal416);
 19903  2
 
 19904  
 
 19905  8
                     pushFollow(FOLLOW_expression_in_builtInCall5416);
 19906  8
                     expression417=expression();
 19907  
 
 19908  8
                     state._fsp--;
 19909  
 
 19910  8
                     stream_expression.add(expression417.getTree());
 19911  
 
 19912  8
                     char_literal418=(Token)match(input,210,FOLLOW_210_in_builtInCall5418);  
 19913  10
                     stream_210.add(char_literal418);
 19914  2
 
 19915  
 
 19916  2
                     // AST REWRITE
 19917  
                     // elements: expression, URI
 19918  
                     // token labels: 
 19919  
                     // rule labels: retval
 19920  
                     // token list labels: 
 19921  2
                     // rule list labels: 
 19922  2
                     // wildcard labels: 
 19923  8
                     retval.tree = root_0;
 19924  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19925  
 
 19926  10
                     root_0 = (Object)adaptor.nil();
 19927  
                     // 579:30: -> ^( URI expression )
 19928  2
                     {
 19929  
                         // com\\googlecode\\sparkleg\\Sparql.g:579:33: ^( URI expression )
 19930  
                         {
 19931  8
                         Object root_1 = (Object)adaptor.nil();
 19932  8
                         root_1 = (Object)adaptor.becomeRoot(
 19933  
                         stream_URI.nextNode()
 19934  2
                         , root_1);
 19935  
 
 19936  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19937  2
 
 19938  8
                         adaptor.addChild(root_0, root_1);
 19939  
                         }
 19940  
 
 19941  2
                     }
 19942  2
 
 19943  
 
 19944  8
                     retval.tree = root_0;
 19945  2
 
 19946  2
                     }
 19947  8
                     break;
 19948  
                 case 8 :
 19949  2
                     // com\\googlecode\\sparkleg\\Sparql.g:580:7: BNODE ( '(' expression ')' )
 19950  2
                     {
 19951  16
                     BNODE419=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5434);  
 19952  18
                     stream_BNODE.add(BNODE419);
 19953  
 
 19954  2
 
 19955  
                     // com\\googlecode\\sparkleg\\Sparql.g:580:13: ( '(' expression ')' )
 19956  2
                     // com\\googlecode\\sparkleg\\Sparql.g:580:14: '(' expression ')'
 19957  2
                     {
 19958  16
                     char_literal420=(Token)match(input,209,FOLLOW_209_in_builtInCall5437);  
 19959  16
                     stream_209.add(char_literal420);
 19960  
 
 19961  
 
 19962  16
                     pushFollow(FOLLOW_expression_in_builtInCall5439);
 19963  16
                     expression421=expression();
 19964  
 
 19965  16
                     state._fsp--;
 19966  
 
 19967  18
                     stream_expression.add(expression421.getTree());
 19968  2
 
 19969  16
                     char_literal422=(Token)match(input,210,FOLLOW_210_in_builtInCall5441);  
 19970  18
                     stream_210.add(char_literal422);
 19971  
 
 19972  
 
 19973  
                     }
 19974  
 
 19975  2
 
 19976  2
                     // AST REWRITE
 19977  
                     // elements: BNODE, expression
 19978  
                     // token labels: 
 19979  
                     // rule labels: retval
 19980  2
                     // token list labels: 
 19981  
                     // rule list labels: 
 19982  2
                     // wildcard labels: 
 19983  16
                     retval.tree = root_0;
 19984  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19985  
 
 19986  16
                     root_0 = (Object)adaptor.nil();
 19987  
                     // 580:34: -> ^( BNODE expression )
 19988  2
                     {
 19989  
                         // com\\googlecode\\sparkleg\\Sparql.g:580:37: ^( BNODE expression )
 19990  
                         {
 19991  18
                         Object root_1 = (Object)adaptor.nil();
 19992  16
                         root_1 = (Object)adaptor.becomeRoot(
 19993  
                         stream_BNODE.nextNode()
 19994  
                         , root_1);
 19995  2
 
 19996  18
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19997  
 
 19998  16
                         adaptor.addChild(root_0, root_1);
 19999  2
                         }
 20000  2
 
 20001  
                     }
 20002  
 
 20003  2
 
 20004  18
                     retval.tree = root_0;
 20005  
 
 20006  2
                     }
 20007  16
                     break;
 20008  2
                 case 9 :
 20009  
                     // com\\googlecode\\sparkleg\\Sparql.g:581:7: BNODE nil
 20010  2
                     {
 20011  18
                     BNODE423=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5458);  
 20012  16
                     stream_BNODE.add(BNODE423);
 20013  
 
 20014  
 
 20015  16
                     pushFollow(FOLLOW_nil_in_builtInCall5460);
 20016  16
                     nil424=nil();
 20017  
 
 20018  16
                     state._fsp--;
 20019  
 
 20020  16
                     stream_nil.add(nil424.getTree());
 20021  2
 
 20022  2
                     // AST REWRITE
 20023  
                     // elements: BNODE
 20024  2
                     // token labels: 
 20025  
                     // rule labels: retval
 20026  
                     // token list labels: 
 20027  
                     // rule list labels: 
 20028  
                     // wildcard labels: 
 20029  18
                     retval.tree = root_0;
 20030  18
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20031  
 
 20032  16
                     root_0 = (Object)adaptor.nil();
 20033  
                     // 581:17: -> BNODE
 20034  2
                     {
 20035  16
                         adaptor.addChild(root_0, 
 20036  2
                         stream_BNODE.nextNode()
 20037  
                         );
 20038  
 
 20039  
                     }
 20040  
 
 20041  
 
 20042  18
                     retval.tree = root_0;
 20043  
 
 20044  
                     }
 20045  18
                     break;
 20046  
                 case 10 :
 20047  
                     // com\\googlecode\\sparkleg\\Sparql.g:582:7: RAND nil
 20048  
                     {
 20049  10
                     RAND425=(Token)match(input,RAND,FOLLOW_RAND_in_builtInCall5472);  
 20050  10
                     stream_RAND.add(RAND425);
 20051  
 
 20052  
 
 20053  10
                     pushFollow(FOLLOW_nil_in_builtInCall5474);
 20054  10
                     nil426=nil();
 20055  
 
 20056  8
                     state._fsp--;
 20057  2
 
 20058  10
                     stream_nil.add(nil426.getTree());
 20059  
 
 20060  2
                     // AST REWRITE
 20061  
                     // elements: RAND
 20062  2
                     // token labels: 
 20063  
                     // rule labels: retval
 20064  2
                     // token list labels: 
 20065  2
                     // rule list labels: 
 20066  
                     // wildcard labels: 
 20067  8
                     retval.tree = root_0;
 20068  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20069  
 
 20070  8
                     root_0 = (Object)adaptor.nil();
 20071  
                     // 582:16: -> RAND
 20072  
                     {
 20073  8
                         adaptor.addChild(root_0, 
 20074  
                         stream_RAND.nextNode()
 20075  2
                         );
 20076  2
 
 20077  
                     }
 20078  2
 
 20079  
 
 20080  8
                     retval.tree = root_0;
 20081  
 
 20082  
                     }
 20083  10
                     break;
 20084  2
                 case 11 :
 20085  
                     // com\\googlecode\\sparkleg\\Sparql.g:583:7: ABS '(' expression ')'
 20086  
                     {
 20087  8
                     ABS427=(Token)match(input,ABS,FOLLOW_ABS_in_builtInCall5486);  
 20088  10
                     stream_ABS.add(ABS427);
 20089  
 
 20090  2
 
 20091  8
                     char_literal428=(Token)match(input,209,FOLLOW_209_in_builtInCall5488);  
 20092  8
                     stream_209.add(char_literal428);
 20093  
 
 20094  
 
 20095  8
                     pushFollow(FOLLOW_expression_in_builtInCall5490);
 20096  10
                     expression429=expression();
 20097  
 
 20098  8
                     state._fsp--;
 20099  2
 
 20100  8
                     stream_expression.add(expression429.getTree());
 20101  
 
 20102  8
                     char_literal430=(Token)match(input,210,FOLLOW_210_in_builtInCall5492);  
 20103  18
                     stream_210.add(char_literal430);
 20104  10
 
 20105  
 
 20106  
                     // AST REWRITE
 20107  10
                     // elements: ABS, expression
 20108  10
                     // token labels: 
 20109  
                     // rule labels: retval
 20110  10
                     // token list labels: 
 20111  
                     // rule list labels: 
 20112  10
                     // wildcard labels: 
 20113  8
                     retval.tree = root_0;
 20114  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20115  
 
 20116  8
                     root_0 = (Object)adaptor.nil();
 20117  
                     // 583:30: -> ^( ABS expression )
 20118  
                     {
 20119  
                         // com\\googlecode\\sparkleg\\Sparql.g:583:33: ^( ABS expression )
 20120  
                         {
 20121  18
                         Object root_1 = (Object)adaptor.nil();
 20122  18
                         root_1 = (Object)adaptor.becomeRoot(
 20123  
                         stream_ABS.nextNode()
 20124  10
                         , root_1);
 20125  
 
 20126  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20127  
 
 20128  8
                         adaptor.addChild(root_0, root_1);
 20129  10
                         }
 20130  10
 
 20131  
                     }
 20132  
 
 20133  
 
 20134  18
                     retval.tree = root_0;
 20135  
 
 20136  10
                     }
 20137  8
                     break;
 20138  
                 case 12 :
 20139  
                     // com\\googlecode\\sparkleg\\Sparql.g:584:7: CEIL '(' expression ')'
 20140  
                     {
 20141  8
                     CEIL431=(Token)match(input,CEIL,FOLLOW_CEIL_in_builtInCall5508);  
 20142  18
                     stream_CEIL.add(CEIL431);
 20143  
 
 20144  
 
 20145  18
                     char_literal432=(Token)match(input,209,FOLLOW_209_in_builtInCall5510);  
 20146  8
                     stream_209.add(char_literal432);
 20147  
 
 20148  
 
 20149  12
                     pushFollow(FOLLOW_expression_in_builtInCall5512);
 20150  12
                     expression433=expression();
 20151  
 
 20152  12
                     state._fsp--;
 20153  
 
 20154  12
                     stream_expression.add(expression433.getTree());
 20155  
 
 20156  8
                     char_literal434=(Token)match(input,210,FOLLOW_210_in_builtInCall5514);  
 20157  8
                     stream_210.add(char_literal434);
 20158  
 
 20159  
 
 20160  
                     // AST REWRITE
 20161  
                     // elements: expression, CEIL
 20162  
                     // token labels: 
 20163  4
                     // rule labels: retval
 20164  4
                     // token list labels: 
 20165  
                     // rule list labels: 
 20166  4
                     // wildcard labels: 
 20167  8
                     retval.tree = root_0;
 20168  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20169  4
 
 20170  8
                     root_0 = (Object)adaptor.nil();
 20171  
                     // 584:31: -> ^( CEIL expression )
 20172  
                     {
 20173  
                         // com\\googlecode\\sparkleg\\Sparql.g:584:34: ^( CEIL expression )
 20174  4
                         {
 20175  8
                         Object root_1 = (Object)adaptor.nil();
 20176  8
                         root_1 = (Object)adaptor.becomeRoot(
 20177  4
                         stream_CEIL.nextNode()
 20178  
                         , root_1);
 20179  
 
 20180  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20181  6
 
 20182  14
                         adaptor.addChild(root_0, root_1);
 20183  
                         }
 20184  6
 
 20185  
                     }
 20186  6
 
 20187  
 
 20188  8
                     retval.tree = root_0;
 20189  
 
 20190  
                     }
 20191  8
                     break;
 20192  
                 case 13 :
 20193  
                     // com\\googlecode\\sparkleg\\Sparql.g:585:7: FLOOR '(' expression ')'
 20194  
                     {
 20195  14
                     FLOOR435=(Token)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall5530);  
 20196  14
                     stream_FLOOR.add(FLOOR435);
 20197  
 
 20198  6
 
 20199  8
                     char_literal436=(Token)match(input,209,FOLLOW_209_in_builtInCall5532);  
 20200  8
                     stream_209.add(char_literal436);
 20201  6
 
 20202  
 
 20203  8
                     pushFollow(FOLLOW_expression_in_builtInCall5534);
 20204  8
                     expression437=expression();
 20205  
 
 20206  14
                     state._fsp--;
 20207  
 
 20208  8
                     stream_expression.add(expression437.getTree());
 20209  6
 
 20210  8
                     char_literal438=(Token)match(input,210,FOLLOW_210_in_builtInCall5536);  
 20211  8
                     stream_210.add(char_literal438);
 20212  
 
 20213  2
 
 20214  2
                     // AST REWRITE
 20215  
                     // elements: FLOOR, expression
 20216  
                     // token labels: 
 20217  2
                     // rule labels: retval
 20218  2
                     // token list labels: 
 20219  
                     // rule list labels: 
 20220  
                     // wildcard labels: 
 20221  10
                     retval.tree = root_0;
 20222  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20223  
 
 20224  10
                     root_0 = (Object)adaptor.nil();
 20225  
                     // 585:32: -> ^( FLOOR expression )
 20226  2
                     {
 20227  
                         // com\\googlecode\\sparkleg\\Sparql.g:585:35: ^( FLOOR expression )
 20228  2
                         {
 20229  10
                         Object root_1 = (Object)adaptor.nil();
 20230  8
                         root_1 = (Object)adaptor.becomeRoot(
 20231  
                         stream_FLOOR.nextNode()
 20232  
                         , root_1);
 20233  
 
 20234  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20235  
 
 20236  8
                         adaptor.addChild(root_0, root_1);
 20237  
                         }
 20238  
 
 20239  2
                     }
 20240  2
 
 20241  
 
 20242  10
                     retval.tree = root_0;
 20243  
 
 20244  
                     }
 20245  8
                     break;
 20246  
                 case 14 :
 20247  2
                     // com\\googlecode\\sparkleg\\Sparql.g:586:7: ROUND '(' expression ')'
 20248  2
                     {
 20249  8
                     ROUND439=(Token)match(input,ROUND,FOLLOW_ROUND_in_builtInCall5552);  
 20250  8
                     stream_ROUND.add(ROUND439);
 20251  
 
 20252  2
 
 20253  8
                     char_literal440=(Token)match(input,209,FOLLOW_209_in_builtInCall5554);  
 20254  10
                     stream_209.add(char_literal440);
 20255  
 
 20256  
 
 20257  8
                     pushFollow(FOLLOW_expression_in_builtInCall5556);
 20258  8
                     expression441=expression();
 20259  
 
 20260  10
                     state._fsp--;
 20261  
 
 20262  8
                     stream_expression.add(expression441.getTree());
 20263  2
 
 20264  8
                     char_literal442=(Token)match(input,210,FOLLOW_210_in_builtInCall5558);  
 20265  8
                     stream_210.add(char_literal442);
 20266  
 
 20267  2
 
 20268  2
                     // AST REWRITE
 20269  
                     // elements: ROUND, expression
 20270  
                     // token labels: 
 20271  2
                     // rule labels: retval
 20272  2
                     // token list labels: 
 20273  
                     // rule list labels: 
 20274  
                     // wildcard labels: 
 20275  10
                     retval.tree = root_0;
 20276  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20277  
 
 20278  10
                     root_0 = (Object)adaptor.nil();
 20279  
                     // 586:32: -> ^( ROUND expression )
 20280  2
                     {
 20281  
                         // com\\googlecode\\sparkleg\\Sparql.g:586:35: ^( ROUND expression )
 20282  2
                         {
 20283  10
                         Object root_1 = (Object)adaptor.nil();
 20284  8
                         root_1 = (Object)adaptor.becomeRoot(
 20285  
                         stream_ROUND.nextNode()
 20286  
                         , root_1);
 20287  
 
 20288  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20289  
 
 20290  8
                         adaptor.addChild(root_0, root_1);
 20291  
                         }
 20292  
 
 20293  2
                     }
 20294  2
 
 20295  
 
 20296  10
                     retval.tree = root_0;
 20297  
 
 20298  
                     }
 20299  8
                     break;
 20300  
                 case 15 :
 20301  2
                     // com\\googlecode\\sparkleg\\Sparql.g:587:7: CONCAT expressionList
 20302  2
                     {
 20303  40
                     CONCAT443=(Token)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall5574);  
 20304  40
                     stream_CONCAT.add(CONCAT443);
 20305  
 
 20306  2
 
 20307  40
                     pushFollow(FOLLOW_expressionList_in_builtInCall5576);
 20308  42
                     expressionList444=expressionList();
 20309  
 
 20310  40
                     state._fsp--;
 20311  
 
 20312  40
                     stream_expressionList.add(expressionList444.getTree());
 20313  
 
 20314  2
                     // AST REWRITE
 20315  
                     // elements: expressionList, CONCAT
 20316  
                     // token labels: 
 20317  2
                     // rule labels: retval
 20318  
                     // token list labels: 
 20319  
                     // rule list labels: 
 20320  
                     // wildcard labels: 
 20321  42
                     retval.tree = root_0;
 20322  42
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20323  
 
 20324  40
                     root_0 = (Object)adaptor.nil();
 20325  2
                     // 587:29: -> ^( CONCAT expressionList )
 20326  2
                     {
 20327  
                         // com\\googlecode\\sparkleg\\Sparql.g:587:32: ^( CONCAT expressionList )
 20328  
                         {
 20329  42
                         Object root_1 = (Object)adaptor.nil();
 20330  42
                         root_1 = (Object)adaptor.becomeRoot(
 20331  
                         stream_CONCAT.nextNode()
 20332  2
                         , root_1);
 20333  
 
 20334  42
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 20335  
 
 20336  42
                         adaptor.addChild(root_0, root_1);
 20337  2
                         }
 20338  
 
 20339  
                     }
 20340  
 
 20341  
 
 20342  40
                     retval.tree = root_0;
 20343  
 
 20344  
                     }
 20345  40
                     break;
 20346  
                 case 16 :
 20347  2
                     // com\\googlecode\\sparkleg\\Sparql.g:588:7: subStringExpression
 20348  2
                     {
 20349  16
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall5592);
 20350  18
                     subStringExpression445=subStringExpression();
 20351  
 
 20352  16
                     state._fsp--;
 20353  
 
 20354  16
                     stream_subStringExpression.add(subStringExpression445.getTree());
 20355  2
 
 20356  2
                     // AST REWRITE
 20357  
                     // elements: subStringExpression
 20358  
                     // token labels: 
 20359  
                     // rule labels: retval
 20360  2
                     // token list labels: 
 20361  
                     // rule list labels: 
 20362  2
                     // wildcard labels: 
 20363  16
                     retval.tree = root_0;
 20364  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20365  
 
 20366  16
                     root_0 = (Object)adaptor.nil();
 20367  
                     // 588:27: -> subStringExpression
 20368  2
                     {
 20369  16
                         adaptor.addChild(root_0, stream_subStringExpression.nextTree());
 20370  
 
 20371  2
                     }
 20372  
 
 20373  
 
 20374  16
                     retval.tree = root_0;
 20375  2
 
 20376  2
                     }
 20377  16
                     break;
 20378  
                 case 17 :
 20379  2
                     // com\\googlecode\\sparkleg\\Sparql.g:589:7: strReplaceExpression
 20380  2
                     {
 20381  24
                     pushFollow(FOLLOW_strReplaceExpression_in_builtInCall5604);
 20382  24
                     strReplaceExpression446=strReplaceExpression();
 20383  2
 
 20384  26
                     state._fsp--;
 20385  
 
 20386  26
                     stream_strReplaceExpression.add(strReplaceExpression446.getTree());
 20387  
 
 20388  2
                     // AST REWRITE
 20389  
                     // elements: strReplaceExpression
 20390  2
                     // token labels: 
 20391  2
                     // rule labels: retval
 20392  
                     // token list labels: 
 20393  
                     // rule list labels: 
 20394  
                     // wildcard labels: 
 20395  24
                     retval.tree = root_0;
 20396  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20397  
 
 20398  24
                     root_0 = (Object)adaptor.nil();
 20399  
                     // 589:28: -> strReplaceExpression
 20400  
                     {
 20401  26
                         adaptor.addChild(root_0, stream_strReplaceExpression.nextTree());
 20402  2
 
 20403  
                     }
 20404  2
 
 20405  
 
 20406  24
                     retval.tree = root_0;
 20407  
 
 20408  
                     }
 20409  26
                     break;
 20410  2
                 case 18 :
 20411  
                     // com\\googlecode\\sparkleg\\Sparql.g:590:7: STRLEN '(' expression ')'
 20412  
                     {
 20413  8
                     STRLEN447=(Token)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall5616);  
 20414  10
                     stream_STRLEN.add(STRLEN447);
 20415  
 
 20416  2
 
 20417  8
                     char_literal448=(Token)match(input,209,FOLLOW_209_in_builtInCall5618);  
 20418  8
                     stream_209.add(char_literal448);
 20419  
 
 20420  
 
 20421  8
                     pushFollow(FOLLOW_expression_in_builtInCall5620);
 20422  10
                     expression449=expression();
 20423  
 
 20424  8
                     state._fsp--;
 20425  2
 
 20426  8
                     stream_expression.add(expression449.getTree());
 20427  
 
 20428  8
                     char_literal450=(Token)match(input,210,FOLLOW_210_in_builtInCall5622);  
 20429  10
                     stream_210.add(char_literal450);
 20430  2
 
 20431  
 
 20432  
                     // AST REWRITE
 20433  2
                     // elements: STRLEN, expression
 20434  2
                     // token labels: 
 20435  
                     // rule labels: retval
 20436  
                     // token list labels: 
 20437  2
                     // rule list labels: 
 20438  2
                     // wildcard labels: 
 20439  8
                     retval.tree = root_0;
 20440  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20441  
 
 20442  10
                     root_0 = (Object)adaptor.nil();
 20443  
                     // 590:33: -> ^( STRLEN expression )
 20444  2
                     {
 20445  2
                         // com\\googlecode\\sparkleg\\Sparql.g:590:36: ^( STRLEN expression )
 20446  
                         {
 20447  8
                         Object root_1 = (Object)adaptor.nil();
 20448  10
                         root_1 = (Object)adaptor.becomeRoot(
 20449  2
                         stream_STRLEN.nextNode()
 20450  
                         , root_1);
 20451  2
 
 20452  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20453  2
 
 20454  8
                         adaptor.addChild(root_0, root_1);
 20455  2
                         }
 20456  2
 
 20457  
                     }
 20458  
 
 20459  
 
 20460  8
                     retval.tree = root_0;
 20461  
 
 20462  
                     }
 20463  8
                     break;
 20464  
                 case 19 :
 20465  
                     // com\\googlecode\\sparkleg\\Sparql.g:591:7: UCASE '(' expression ')'
 20466  2
                     {
 20467  10
                     UCASE451=(Token)match(input,UCASE,FOLLOW_UCASE_in_builtInCall5638);  
 20468  8
                     stream_UCASE.add(UCASE451);
 20469  2
 
 20470  
 
 20471  8
                     char_literal452=(Token)match(input,209,FOLLOW_209_in_builtInCall5640);  
 20472  8
                     stream_209.add(char_literal452);
 20473  
 
 20474  2
 
 20475  10
                     pushFollow(FOLLOW_expression_in_builtInCall5642);
 20476  8
                     expression453=expression();
 20477  
 
 20478  8
                     state._fsp--;
 20479  2
 
 20480  8
                     stream_expression.add(expression453.getTree());
 20481  2
 
 20482  8
                     char_literal454=(Token)match(input,210,FOLLOW_210_in_builtInCall5644);  
 20483  10
                     stream_210.add(char_literal454);
 20484  
 
 20485  
 
 20486  
                     // AST REWRITE
 20487  
                     // elements: expression, UCASE
 20488  
                     // token labels: 
 20489  2
                     // rule labels: retval
 20490  
                     // token list labels: 
 20491  
                     // rule list labels: 
 20492  2
                     // wildcard labels: 
 20493  8
                     retval.tree = root_0;
 20494  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20495  
 
 20496  10
                     root_0 = (Object)adaptor.nil();
 20497  2
                     // 591:32: -> ^( UCASE expression )
 20498  
                     {
 20499  
                         // com\\googlecode\\sparkleg\\Sparql.g:591:35: ^( UCASE expression )
 20500  2
                         {
 20501  10
                         Object root_1 = (Object)adaptor.nil();
 20502  8
                         root_1 = (Object)adaptor.becomeRoot(
 20503  
                         stream_UCASE.nextNode()
 20504  2
                         , root_1);
 20505  2
 
 20506  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20507  2
 
 20508  8
                         adaptor.addChild(root_0, root_1);
 20509  2
                         }
 20510  
 
 20511  2
                     }
 20512  2
 
 20513  
 
 20514  8
                     retval.tree = root_0;
 20515  2
 
 20516  2
                     }
 20517  8
                     break;
 20518  2
                 case 20 :
 20519  
                     // com\\googlecode\\sparkleg\\Sparql.g:592:7: LCASE '(' expression ')'
 20520  2
                     {
 20521  8
                     LCASE455=(Token)match(input,LCASE,FOLLOW_LCASE_in_builtInCall5660);  
 20522  10
                     stream_LCASE.add(LCASE455);
 20523  2
 
 20524  
 
 20525  8
                     char_literal456=(Token)match(input,209,FOLLOW_209_in_builtInCall5662);  
 20526  8
                     stream_209.add(char_literal456);
 20527  
 
 20528  
 
 20529  8
                     pushFollow(FOLLOW_expression_in_builtInCall5664);
 20530  8
                     expression457=expression();
 20531  
 
 20532  8
                     state._fsp--;
 20533  2
 
 20534  10
                     stream_expression.add(expression457.getTree());
 20535  
 
 20536  10
                     char_literal458=(Token)match(input,210,FOLLOW_210_in_builtInCall5666);  
 20537  8
                     stream_210.add(char_literal458);
 20538  
 
 20539  
 
 20540  
                     // AST REWRITE
 20541  2
                     // elements: LCASE, expression
 20542  2
                     // token labels: 
 20543  
                     // rule labels: retval
 20544  
                     // token list labels: 
 20545  
                     // rule list labels: 
 20546  2
                     // wildcard labels: 
 20547  8
                     retval.tree = root_0;
 20548  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20549  
 
 20550  10
                     root_0 = (Object)adaptor.nil();
 20551  
                     // 592:32: -> ^( LCASE expression )
 20552  
                     {
 20553  
                         // com\\googlecode\\sparkleg\\Sparql.g:592:35: ^( LCASE expression )
 20554  
                         {
 20555  8
                         Object root_1 = (Object)adaptor.nil();
 20556  10
                         root_1 = (Object)adaptor.becomeRoot(
 20557  
                         stream_LCASE.nextNode()
 20558  
                         , root_1);
 20559  2
 
 20560  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20561  
 
 20562  8
                         adaptor.addChild(root_0, root_1);
 20563  2
                         }
 20564  2
 
 20565  
                     }
 20566  
 
 20567  2
 
 20568  10
                     retval.tree = root_0;
 20569  
 
 20570  
                     }
 20571  10
                     break;
 20572  2
                 case 21 :
 20573  
                     // com\\googlecode\\sparkleg\\Sparql.g:593:7: ENCODE_FOR_URI '(' expression ')'
 20574  2
                     {
 20575  8
                     ENCODE_FOR_URI459=(Token)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall5682);  
 20576  10
                     stream_ENCODE_FOR_URI.add(ENCODE_FOR_URI459);
 20577  
 
 20578  2
 
 20579  10
                     char_literal460=(Token)match(input,209,FOLLOW_209_in_builtInCall5684);  
 20580  8
                     stream_209.add(char_literal460);
 20581  
 
 20582  2
 
 20583  10
                     pushFollow(FOLLOW_expression_in_builtInCall5686);
 20584  8
                     expression461=expression();
 20585  2
 
 20586  8
                     state._fsp--;
 20587  2
 
 20588  8
                     stream_expression.add(expression461.getTree());
 20589  2
 
 20590  10
                     char_literal462=(Token)match(input,210,FOLLOW_210_in_builtInCall5688);  
 20591  8
                     stream_210.add(char_literal462);
 20592  
 
 20593  
 
 20594  
                     // AST REWRITE
 20595  
                     // elements: expression, ENCODE_FOR_URI
 20596  
                     // token labels: 
 20597  
                     // rule labels: retval
 20598  
                     // token list labels: 
 20599  
                     // rule list labels: 
 20600  2
                     // wildcard labels: 
 20601  10
                     retval.tree = root_0;
 20602  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20603  2
 
 20604  8
                     root_0 = (Object)adaptor.nil();
 20605  
                     // 593:41: -> ^( ENCODE_FOR_URI expression )
 20606  
                     {
 20607  
                         // com\\googlecode\\sparkleg\\Sparql.g:593:44: ^( ENCODE_FOR_URI expression )
 20608  2
                         {
 20609  10
                         Object root_1 = (Object)adaptor.nil();
 20610  8
                         root_1 = (Object)adaptor.becomeRoot(
 20611  
                         stream_ENCODE_FOR_URI.nextNode()
 20612  
                         , root_1);
 20613  2
 
 20614  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20615  2
 
 20616  8
                         adaptor.addChild(root_0, root_1);
 20617  2
                         }
 20618  
 
 20619  
                     }
 20620  
 
 20621  
 
 20622  8
                     retval.tree = root_0;
 20623  2
 
 20624  
                     }
 20625  8
                     break;
 20626  2
                 case 22 :
 20627  
                     // com\\googlecode\\sparkleg\\Sparql.g:594:7: CONTAINS '(' expression ',' expression ')'
 20628  
                     {
 20629  8
                     CONTAINS463=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall5704);  
 20630  10
                     stream_CONTAINS.add(CONTAINS463);
 20631  2
 
 20632  
 
 20633  8
                     char_literal464=(Token)match(input,209,FOLLOW_209_in_builtInCall5706);  
 20634  10
                     stream_209.add(char_literal464);
 20635  2
 
 20636  
 
 20637  8
                     pushFollow(FOLLOW_expression_in_builtInCall5708);
 20638  10
                     expression465=expression();
 20639  2
 
 20640  8
                     state._fsp--;
 20641  2
 
 20642  8
                     stream_expression.add(expression465.getTree());
 20643  2
 
 20644  8
                     char_literal466=(Token)match(input,211,FOLLOW_211_in_builtInCall5710);  
 20645  10
                     stream_211.add(char_literal466);
 20646  2
 
 20647  
 
 20648  8
                     pushFollow(FOLLOW_expression_in_builtInCall5712);
 20649  10
                     expression467=expression();
 20650  2
 
 20651  8
                     state._fsp--;
 20652  2
 
 20653  8
                     stream_expression.add(expression467.getTree());
 20654  2
 
 20655  8
                     char_literal468=(Token)match(input,210,FOLLOW_210_in_builtInCall5714);  
 20656  10
                     stream_210.add(char_literal468);
 20657  2
 
 20658  
 
 20659  
                     // AST REWRITE
 20660  
                     // elements: CONTAINS, expression, expression
 20661  
                     // token labels: 
 20662  
                     // rule labels: retval
 20663  
                     // token list labels: 
 20664  
                     // rule list labels: 
 20665  
                     // wildcard labels: 
 20666  8
                     retval.tree = root_0;
 20667  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20668  2
 
 20669  8
                     root_0 = (Object)adaptor.nil();
 20670  2
                     // 594:50: -> ^( CONTAINS expression expression )
 20671  
                     {
 20672  
                         // com\\googlecode\\sparkleg\\Sparql.g:594:53: ^( CONTAINS expression expression )
 20673  
                         {
 20674  8
                         Object root_1 = (Object)adaptor.nil();
 20675  10
                         root_1 = (Object)adaptor.becomeRoot(
 20676  2
                         stream_CONTAINS.nextNode()
 20677  
                         , root_1);
 20678  
 
 20679  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20680  2
 
 20681  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20682  2
 
 20683  8
                         adaptor.addChild(root_0, root_1);
 20684  2
                         }
 20685  
 
 20686  
                     }
 20687  
 
 20688  
 
 20689  8
                     retval.tree = root_0;
 20690  2
 
 20691  
                     }
 20692  8
                     break;
 20693  2
                 case 23 :
 20694  
                     // com\\googlecode\\sparkleg\\Sparql.g:595:7: STRSTARTS '(' expression ',' expression ')'
 20695  
                     {
 20696  8
                     STRSTARTS469=(Token)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall5732);  
 20697  10
                     stream_STRSTARTS.add(STRSTARTS469);
 20698  2
 
 20699  
 
 20700  8
                     char_literal470=(Token)match(input,209,FOLLOW_209_in_builtInCall5734);  
 20701  10
                     stream_209.add(char_literal470);
 20702  2
 
 20703  
 
 20704  8
                     pushFollow(FOLLOW_expression_in_builtInCall5736);
 20705  10
                     expression471=expression();
 20706  2
 
 20707  8
                     state._fsp--;
 20708  2
 
 20709  8
                     stream_expression.add(expression471.getTree());
 20710  2
 
 20711  8
                     char_literal472=(Token)match(input,211,FOLLOW_211_in_builtInCall5738);  
 20712  10
                     stream_211.add(char_literal472);
 20713  2
 
 20714  
 
 20715  8
                     pushFollow(FOLLOW_expression_in_builtInCall5740);
 20716  10
                     expression473=expression();
 20717  2
 
 20718  8
                     state._fsp--;
 20719  2
 
 20720  8
                     stream_expression.add(expression473.getTree());
 20721  2
 
 20722  8
                     char_literal474=(Token)match(input,210,FOLLOW_210_in_builtInCall5742);  
 20723  10
                     stream_210.add(char_literal474);
 20724  2
 
 20725  
 
 20726  
                     // AST REWRITE
 20727  
                     // elements: STRSTARTS, expression, expression
 20728  
                     // token labels: 
 20729  
                     // rule labels: retval
 20730  
                     // token list labels: 
 20731  
                     // rule list labels: 
 20732  
                     // wildcard labels: 
 20733  8
                     retval.tree = root_0;
 20734  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20735  2
 
 20736  8
                     root_0 = (Object)adaptor.nil();
 20737  2
                     // 595:51: -> ^( STRSTARTS expression expression )
 20738  
                     {
 20739  
                         // com\\googlecode\\sparkleg\\Sparql.g:595:54: ^( STRSTARTS expression expression )
 20740  
                         {
 20741  8
                         Object root_1 = (Object)adaptor.nil();
 20742  10
                         root_1 = (Object)adaptor.becomeRoot(
 20743  2
                         stream_STRSTARTS.nextNode()
 20744  
                         , root_1);
 20745  
 
 20746  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20747  2
 
 20748  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20749  2
 
 20750  8
                         adaptor.addChild(root_0, root_1);
 20751  2
                         }
 20752  
 
 20753  
                     }
 20754  
 
 20755  
 
 20756  8
                     retval.tree = root_0;
 20757  2
 
 20758  
                     }
 20759  8
                     break;
 20760  2
                 case 24 :
 20761  
                     // com\\googlecode\\sparkleg\\Sparql.g:596:7: STRENDS '(' expression ',' expression ')'
 20762  
                     {
 20763  8
                     STRENDS475=(Token)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall5760);  
 20764  10
                     stream_STRENDS.add(STRENDS475);
 20765  2
 
 20766  
 
 20767  8
                     char_literal476=(Token)match(input,209,FOLLOW_209_in_builtInCall5762);  
 20768  10
                     stream_209.add(char_literal476);
 20769  2
 
 20770  
 
 20771  8
                     pushFollow(FOLLOW_expression_in_builtInCall5764);
 20772  10
                     expression477=expression();
 20773  2
 
 20774  8
                     state._fsp--;
 20775  2
 
 20776  8
                     stream_expression.add(expression477.getTree());
 20777  2
 
 20778  8
                     char_literal478=(Token)match(input,211,FOLLOW_211_in_builtInCall5766);  
 20779  10
                     stream_211.add(char_literal478);
 20780  2
 
 20781  
 
 20782  8
                     pushFollow(FOLLOW_expression_in_builtInCall5768);
 20783  8
                     expression479=expression();
 20784  
 
 20785  8
                     state._fsp--;
 20786  
 
 20787  8
                     stream_expression.add(expression479.getTree());
 20788  
 
 20789  8
                     char_literal480=(Token)match(input,210,FOLLOW_210_in_builtInCall5770);  
 20790  10
                     stream_210.add(char_literal480);
 20791  2
 
 20792  
 
 20793  2
                     // AST REWRITE
 20794  
                     // elements: expression, STRENDS, expression
 20795  
                     // token labels: 
 20796  
                     // rule labels: retval
 20797  
                     // token list labels: 
 20798  2
                     // rule list labels: 
 20799  2
                     // wildcard labels: 
 20800  8
                     retval.tree = root_0;
 20801  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20802  
 
 20803  10
                     root_0 = (Object)adaptor.nil();
 20804  
                     // 596:49: -> ^( STRENDS expression expression )
 20805  2
                     {
 20806  
                         // com\\googlecode\\sparkleg\\Sparql.g:596:52: ^( STRENDS expression expression )
 20807  
                         {
 20808  8
                         Object root_1 = (Object)adaptor.nil();
 20809  8
                         root_1 = (Object)adaptor.becomeRoot(
 20810  
                         stream_STRENDS.nextNode()
 20811  2
                         , root_1);
 20812  
 
 20813  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20814  2
 
 20815  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20816  
 
 20817  8
                         adaptor.addChild(root_0, root_1);
 20818  2
                         }
 20819  2
 
 20820  
                     }
 20821  
 
 20822  2
 
 20823  10
                     retval.tree = root_0;
 20824  
 
 20825  
                     }
 20826  10
                     break;
 20827  2
                 case 25 :
 20828  
                     // com\\googlecode\\sparkleg\\Sparql.g:597:7: STRBEFORE '(' expression ',' expression ')'
 20829  2
                     {
 20830  8
                     STRBEFORE481=(Token)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall5788);  
 20831  10
                     stream_STRBEFORE.add(STRBEFORE481);
 20832  
 
 20833  2
 
 20834  10
                     char_literal482=(Token)match(input,209,FOLLOW_209_in_builtInCall5790);  
 20835  8
                     stream_209.add(char_literal482);
 20836  
 
 20837  
 
 20838  8
                     pushFollow(FOLLOW_expression_in_builtInCall5792);
 20839  8
                     expression483=expression();
 20840  
 
 20841  8
                     state._fsp--;
 20842  
 
 20843  8
                     stream_expression.add(expression483.getTree());
 20844  2
 
 20845  10
                     char_literal484=(Token)match(input,211,FOLLOW_211_in_builtInCall5794);  
 20846  8
                     stream_211.add(char_literal484);
 20847  2
 
 20848  
 
 20849  8
                     pushFollow(FOLLOW_expression_in_builtInCall5796);
 20850  8
                     expression485=expression();
 20851  
 
 20852  10
                     state._fsp--;
 20853  2
 
 20854  8
                     stream_expression.add(expression485.getTree());
 20855  
 
 20856  8
                     char_literal486=(Token)match(input,210,FOLLOW_210_in_builtInCall5798);  
 20857  10
                     stream_210.add(char_literal486);
 20858  
 
 20859  2
 
 20860  
                     // AST REWRITE
 20861  
                     // elements: STRBEFORE, expression, expression
 20862  
                     // token labels: 
 20863  
                     // rule labels: retval
 20864  
                     // token list labels: 
 20865  2
                     // rule list labels: 
 20866  
                     // wildcard labels: 
 20867  8
                     retval.tree = root_0;
 20868  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20869  
 
 20870  8
                     root_0 = (Object)adaptor.nil();
 20871  
                     // 597:51: -> ^( STRBEFORE expression expression )
 20872  2
                     {
 20873  2
                         // com\\googlecode\\sparkleg\\Sparql.g:597:54: ^( STRBEFORE expression expression )
 20874  
                         {
 20875  8
                         Object root_1 = (Object)adaptor.nil();
 20876  10
                         root_1 = (Object)adaptor.becomeRoot(
 20877  2
                         stream_STRBEFORE.nextNode()
 20878  
                         , root_1);
 20879  
 
 20880  10
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20881  2
 
 20882  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20883  2
 
 20884  8
                         adaptor.addChild(root_0, root_1);
 20885  2
                         }
 20886  
 
 20887  2
                     }
 20888  2
 
 20889  
 
 20890  8
                     retval.tree = root_0;
 20891  
 
 20892  
                     }
 20893  8
                     break;
 20894  
                 case 26 :
 20895  
                     // com\\googlecode\\sparkleg\\Sparql.g:598:7: STRAFTER '(' expression ',' expression ')'
 20896  
                     {
 20897  8
                     STRAFTER487=(Token)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall5816);  
 20898  10
                     stream_STRAFTER.add(STRAFTER487);
 20899  2
 
 20900  
 
 20901  10
                     char_literal488=(Token)match(input,209,FOLLOW_209_in_builtInCall5818);  
 20902  8
                     stream_209.add(char_literal488);
 20903  
 
 20904  
 
 20905  8
                     pushFollow(FOLLOW_expression_in_builtInCall5820);
 20906  10
                     expression489=expression();
 20907  2
 
 20908  8
                     state._fsp--;
 20909  
 
 20910  8
                     stream_expression.add(expression489.getTree());
 20911  2
 
 20912  8
                     char_literal490=(Token)match(input,211,FOLLOW_211_in_builtInCall5822);  
 20913  10
                     stream_211.add(char_literal490);
 20914  
 
 20915  
 
 20916  8
                     pushFollow(FOLLOW_expression_in_builtInCall5824);
 20917  8
                     expression491=expression();
 20918  
 
 20919  10
                     state._fsp--;
 20920  
 
 20921  8
                     stream_expression.add(expression491.getTree());
 20922  2
 
 20923  8
                     char_literal492=(Token)match(input,210,FOLLOW_210_in_builtInCall5826);  
 20924  8
                     stream_210.add(char_literal492);
 20925  
 
 20926  2
 
 20927  2
                     // AST REWRITE
 20928  
                     // elements: expression, expression, STRAFTER
 20929  
                     // token labels: 
 20930  2
                     // rule labels: retval
 20931  2
                     // token list labels: 
 20932  
                     // rule list labels: 
 20933  
                     // wildcard labels: 
 20934  10
                     retval.tree = root_0;
 20935  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20936  
 
 20937  10
                     root_0 = (Object)adaptor.nil();
 20938  
                     // 598:50: -> ^( STRAFTER expression expression )
 20939  2
                     {
 20940  
                         // com\\googlecode\\sparkleg\\Sparql.g:598:53: ^( STRAFTER expression expression )
 20941  2
                         {
 20942  10
                         Object root_1 = (Object)adaptor.nil();
 20943  8
                         root_1 = (Object)adaptor.becomeRoot(
 20944  
                         stream_STRAFTER.nextNode()
 20945  
                         , root_1);
 20946  
 
 20947  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20948  
 
 20949  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20950  
 
 20951  8
                         adaptor.addChild(root_0, root_1);
 20952  2
                         }
 20953  2
 
 20954  
                     }
 20955  2
 
 20956  
 
 20957  8
                     retval.tree = root_0;
 20958  
 
 20959  
                     }
 20960  10
                     break;
 20961  2
                 case 27 :
 20962  
                     // com\\googlecode\\sparkleg\\Sparql.g:599:7: YEAR '(' expression ')'
 20963  
                     {
 20964  8
                     YEAR493=(Token)match(input,YEAR,FOLLOW_YEAR_in_builtInCall5844);  
 20965  10
                     stream_YEAR.add(YEAR493);
 20966  
 
 20967  2
 
 20968  8
                     char_literal494=(Token)match(input,209,FOLLOW_209_in_builtInCall5846);  
 20969  8
                     stream_209.add(char_literal494);
 20970  
 
 20971  
 
 20972  8
                     pushFollow(FOLLOW_expression_in_builtInCall5848);
 20973  10
                     expression495=expression();
 20974  
 
 20975  8
                     state._fsp--;
 20976  2
 
 20977  8
                     stream_expression.add(expression495.getTree());
 20978  
 
 20979  8
                     char_literal496=(Token)match(input,210,FOLLOW_210_in_builtInCall5850);  
 20980  10
                     stream_210.add(char_literal496);
 20981  2
 
 20982  
 
 20983  
                     // AST REWRITE
 20984  2
                     // elements: YEAR, expression
 20985  2
                     // token labels: 
 20986  
                     // rule labels: retval
 20987  
                     // token list labels: 
 20988  2
                     // rule list labels: 
 20989  2
                     // wildcard labels: 
 20990  8
                     retval.tree = root_0;
 20991  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20992  
 
 20993  10
                     root_0 = (Object)adaptor.nil();
 20994  
                     // 599:31: -> ^( YEAR expression )
 20995  2
                     {
 20996  2
                         // com\\googlecode\\sparkleg\\Sparql.g:599:34: ^( YEAR expression )
 20997  
                         {
 20998  8
                         Object root_1 = (Object)adaptor.nil();
 20999  8
                         root_1 = (Object)adaptor.becomeRoot(
 21000  
                         stream_YEAR.nextNode()
 21001  
                         , root_1);
 21002  
 
 21003  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21004  
 
 21005  8
                         adaptor.addChild(root_0, root_1);
 21006  2
                         }
 21007  2
 
 21008  
                     }
 21009  2
 
 21010  
 
 21011  8
                     retval.tree = root_0;
 21012  
 
 21013  
                     }
 21014  10
                     break;
 21015  2
                 case 28 :
 21016  
                     // com\\googlecode\\sparkleg\\Sparql.g:600:7: MONTH '(' expression ')'
 21017  
                     {
 21018  8
                     MONTH497=(Token)match(input,MONTH,FOLLOW_MONTH_in_builtInCall5866);  
 21019  10
                     stream_MONTH.add(MONTH497);
 21020  
 
 21021  2
 
 21022  8
                     char_literal498=(Token)match(input,209,FOLLOW_209_in_builtInCall5868);  
 21023  8
                     stream_209.add(char_literal498);
 21024  
 
 21025  
 
 21026  8
                     pushFollow(FOLLOW_expression_in_builtInCall5870);
 21027  10
                     expression499=expression();
 21028  
 
 21029  8
                     state._fsp--;
 21030  2
 
 21031  8
                     stream_expression.add(expression499.getTree());
 21032  
 
 21033  8
                     char_literal500=(Token)match(input,210,FOLLOW_210_in_builtInCall5872);  
 21034  10
                     stream_210.add(char_literal500);
 21035  2
 
 21036  
 
 21037  
                     // AST REWRITE
 21038  2
                     // elements: MONTH, expression
 21039  2
                     // token labels: 
 21040  
                     // rule labels: retval
 21041  
                     // token list labels: 
 21042  2
                     // rule list labels: 
 21043  2
                     // wildcard labels: 
 21044  8
                     retval.tree = root_0;
 21045  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21046  
 
 21047  10
                     root_0 = (Object)adaptor.nil();
 21048  
                     // 600:32: -> ^( MONTH expression )
 21049  2
                     {
 21050  2
                         // com\\googlecode\\sparkleg\\Sparql.g:600:35: ^( MONTH expression )
 21051  
                         {
 21052  8
                         Object root_1 = (Object)adaptor.nil();
 21053  8
                         root_1 = (Object)adaptor.becomeRoot(
 21054  
                         stream_MONTH.nextNode()
 21055  
                         , root_1);
 21056  
 
 21057  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21058  
 
 21059  8
                         adaptor.addChild(root_0, root_1);
 21060  2
                         }
 21061  2
 
 21062  
                     }
 21063  2
 
 21064  
 
 21065  8
                     retval.tree = root_0;
 21066  
 
 21067  
                     }
 21068  10
                     break;
 21069  2
                 case 29 :
 21070  
                     // com\\googlecode\\sparkleg\\Sparql.g:601:7: DAY '(' expression ')'
 21071  
                     {
 21072  8
                     DAY501=(Token)match(input,DAY,FOLLOW_DAY_in_builtInCall5888);  
 21073  10
                     stream_DAY.add(DAY501);
 21074  
 
 21075  2
 
 21076  8
                     char_literal502=(Token)match(input,209,FOLLOW_209_in_builtInCall5890);  
 21077  8
                     stream_209.add(char_literal502);
 21078  
 
 21079  
 
 21080  8
                     pushFollow(FOLLOW_expression_in_builtInCall5892);
 21081  10
                     expression503=expression();
 21082  
 
 21083  8
                     state._fsp--;
 21084  2
 
 21085  8
                     stream_expression.add(expression503.getTree());
 21086  
 
 21087  8
                     char_literal504=(Token)match(input,210,FOLLOW_210_in_builtInCall5894);  
 21088  10
                     stream_210.add(char_literal504);
 21089  2
 
 21090  
 
 21091  
                     // AST REWRITE
 21092  2
                     // elements: DAY, expression
 21093  2
                     // token labels: 
 21094  
                     // rule labels: retval
 21095  
                     // token list labels: 
 21096  2
                     // rule list labels: 
 21097  2
                     // wildcard labels: 
 21098  8
                     retval.tree = root_0;
 21099  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21100  
 
 21101  10
                     root_0 = (Object)adaptor.nil();
 21102  
                     // 601:30: -> ^( DAY expression )
 21103  2
                     {
 21104  2
                         // com\\googlecode\\sparkleg\\Sparql.g:601:33: ^( DAY expression )
 21105  
                         {
 21106  8
                         Object root_1 = (Object)adaptor.nil();
 21107  8
                         root_1 = (Object)adaptor.becomeRoot(
 21108  
                         stream_DAY.nextNode()
 21109  
                         , root_1);
 21110  
 
 21111  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21112  
 
 21113  8
                         adaptor.addChild(root_0, root_1);
 21114  2
                         }
 21115  2
 
 21116  
                     }
 21117  2
 
 21118  
 
 21119  8
                     retval.tree = root_0;
 21120  
 
 21121  
                     }
 21122  10
                     break;
 21123  2
                 case 30 :
 21124  
                     // com\\googlecode\\sparkleg\\Sparql.g:602:7: HOURS '(' expression ')'
 21125  
                     {
 21126  8
                     HOURS505=(Token)match(input,HOURS,FOLLOW_HOURS_in_builtInCall5910);  
 21127  10
                     stream_HOURS.add(HOURS505);
 21128  
 
 21129  2
 
 21130  8
                     char_literal506=(Token)match(input,209,FOLLOW_209_in_builtInCall5912);  
 21131  8
                     stream_209.add(char_literal506);
 21132  
 
 21133  
 
 21134  8
                     pushFollow(FOLLOW_expression_in_builtInCall5914);
 21135  10
                     expression507=expression();
 21136  
 
 21137  8
                     state._fsp--;
 21138  2
 
 21139  8
                     stream_expression.add(expression507.getTree());
 21140  
 
 21141  8
                     char_literal508=(Token)match(input,210,FOLLOW_210_in_builtInCall5916);  
 21142  10
                     stream_210.add(char_literal508);
 21143  2
 
 21144  
 
 21145  
                     // AST REWRITE
 21146  2
                     // elements: HOURS, expression
 21147  2
                     // token labels: 
 21148  
                     // rule labels: retval
 21149  
                     // token list labels: 
 21150  2
                     // rule list labels: 
 21151  2
                     // wildcard labels: 
 21152  8
                     retval.tree = root_0;
 21153  10
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21154  
 
 21155  10
                     root_0 = (Object)adaptor.nil();
 21156  
                     // 602:32: -> ^( HOURS expression )
 21157  2
                     {
 21158  2
                         // com\\googlecode\\sparkleg\\Sparql.g:602:35: ^( HOURS expression )
 21159  
                         {
 21160  8
                         Object root_1 = (Object)adaptor.nil();
 21161  8
                         root_1 = (Object)adaptor.becomeRoot(
 21162  
                         stream_HOURS.nextNode()
 21163  
                         , root_1);
 21164  
 
 21165  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21166  
 
 21167  8
                         adaptor.addChild(root_0, root_1);
 21168  2
                         }
 21169  2
 
 21170  
                     }
 21171  2
 
 21172  
 
 21173  8
                     retval.tree = root_0;
 21174  
 
 21175  
                     }
 21176  10
                     break;
 21177  2
                 case 31 :
 21178  
                     // com\\googlecode\\sparkleg\\Sparql.g:603:7: MINUTES '(' expression ')'
 21179  
                     {
 21180  8
                     MINUTES509=(Token)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall5932);  
 21181  10
                     stream_MINUTES.add(MINUTES509);
 21182  
 
 21183  2
 
 21184  8
                     char_literal510=(Token)match(input,209,FOLLOW_209_in_builtInCall5934);  
 21185  8
                     stream_209.add(char_literal510);
 21186  
 
 21187  
 
 21188  8
                     pushFollow(FOLLOW_expression_in_builtInCall5936);
 21189  10
                     expression511=expression();
 21190  
 
 21191  8
                     state._fsp--;
 21192  2
 
 21193  8
                     stream_expression.add(expression511.getTree());
 21194  
 
 21195  8
                     char_literal512=(Token)match(input,210,FOLLOW_210_in_builtInCall5938);  
 21196  10
                     stream_210.add(char_literal512);
 21197  2
 
 21198  
 
 21199  
                     // AST REWRITE
 21200  2
                     // elements: expression, MINUTES
 21201  2
                     // token labels: 
 21202  
                     // rule labels: retval
 21203  2
                     // token list labels: 
 21204  
                     // rule list labels: 
 21205  2
                     // wildcard labels: 
 21206  8
                     retval.tree = root_0;
 21207  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21208  
 
 21209  8
                     root_0 = (Object)adaptor.nil();
 21210  
                     // 603:34: -> ^( MINUTES expression )
 21211  
                     {
 21212  
                         // com\\googlecode\\sparkleg\\Sparql.g:603:37: ^( MINUTES expression )
 21213  
                         {
 21214  10
                         Object root_1 = (Object)adaptor.nil();
 21215  10
                         root_1 = (Object)adaptor.becomeRoot(
 21216  
                         stream_MINUTES.nextNode()
 21217  2
                         , root_1);
 21218  
 
 21219  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21220  2
 
 21221  8
                         adaptor.addChild(root_0, root_1);
 21222  
                         }
 21223  
 
 21224  
                     }
 21225  
 
 21226  
 
 21227  10
                     retval.tree = root_0;
 21228  
 
 21229  
                     }
 21230  10
                     break;
 21231  
                 case 32 :
 21232  
                     // com\\googlecode\\sparkleg\\Sparql.g:604:7: SECONDS '(' expression ')'
 21233  
                     {
 21234  12
                     SECONDS513=(Token)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall5954);  
 21235  12
                     stream_SECONDS.add(SECONDS513);
 21236  
 
 21237  
 
 21238  12
                     char_literal514=(Token)match(input,209,FOLLOW_209_in_builtInCall5956);  
 21239  12
                     stream_209.add(char_literal514);
 21240  
 
 21241  
 
 21242  12
                     pushFollow(FOLLOW_expression_in_builtInCall5958);
 21243  12
                     expression515=expression();
 21244  
 
 21245  12
                     state._fsp--;
 21246  
 
 21247  12
                     stream_expression.add(expression515.getTree());
 21248  
 
 21249  12
                     char_literal516=(Token)match(input,210,FOLLOW_210_in_builtInCall5960);  
 21250  12
                     stream_210.add(char_literal516);
 21251  
 
 21252  
 
 21253  
                     // AST REWRITE
 21254  
                     // elements: SECONDS, expression
 21255  
                     // token labels: 
 21256  
                     // rule labels: retval
 21257  
                     // token list labels: 
 21258  
                     // rule list labels: 
 21259  
                     // wildcard labels: 
 21260  12
                     retval.tree = root_0;
 21261  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21262  
 
 21263  12
                     root_0 = (Object)adaptor.nil();
 21264  
                     // 604:34: -> ^( SECONDS expression )
 21265  
                     {
 21266  
                         // com\\googlecode\\sparkleg\\Sparql.g:604:37: ^( SECONDS expression )
 21267  
                         {
 21268  12
                         Object root_1 = (Object)adaptor.nil();
 21269  12
                         root_1 = (Object)adaptor.becomeRoot(
 21270  
                         stream_SECONDS.nextNode()
 21271  
                         , root_1);
 21272  
 
 21273  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21274  
 
 21275  12
                         adaptor.addChild(root_0, root_1);
 21276  
                         }
 21277  
 
 21278  
                     }
 21279  
 
 21280  
 
 21281  12
                     retval.tree = root_0;
 21282  
 
 21283  
                     }
 21284  12
                     break;
 21285  
                 case 33 :
 21286  
                     // com\\googlecode\\sparkleg\\Sparql.g:605:7: TIMEZONE '(' expression ')'
 21287  
                     {
 21288  12
                     TIMEZONE517=(Token)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall5976);  
 21289  12
                     stream_TIMEZONE.add(TIMEZONE517);
 21290  
 
 21291  
 
 21292  12
                     char_literal518=(Token)match(input,209,FOLLOW_209_in_builtInCall5978);  
 21293  12
                     stream_209.add(char_literal518);
 21294  
 
 21295  
 
 21296  12
                     pushFollow(FOLLOW_expression_in_builtInCall5980);
 21297  12
                     expression519=expression();
 21298  
 
 21299  12
                     state._fsp--;
 21300  
 
 21301  12
                     stream_expression.add(expression519.getTree());
 21302  
 
 21303  12
                     char_literal520=(Token)match(input,210,FOLLOW_210_in_builtInCall5982);  
 21304  12
                     stream_210.add(char_literal520);
 21305  
 
 21306  
 
 21307  
                     // AST REWRITE
 21308  
                     // elements: TIMEZONE, expression
 21309  
                     // token labels: 
 21310  
                     // rule labels: retval
 21311  
                     // token list labels: 
 21312  
                     // rule list labels: 
 21313  
                     // wildcard labels: 
 21314  12
                     retval.tree = root_0;
 21315  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21316  
 
 21317  12
                     root_0 = (Object)adaptor.nil();
 21318  
                     // 605:35: -> ^( TIMEZONE expression )
 21319  
                     {
 21320  
                         // com\\googlecode\\sparkleg\\Sparql.g:605:38: ^( TIMEZONE expression )
 21321  
                         {
 21322  12
                         Object root_1 = (Object)adaptor.nil();
 21323  12
                         root_1 = (Object)adaptor.becomeRoot(
 21324  
                         stream_TIMEZONE.nextNode()
 21325  
                         , root_1);
 21326  
 
 21327  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21328  
 
 21329  12
                         adaptor.addChild(root_0, root_1);
 21330  
                         }
 21331  
 
 21332  
                     }
 21333  
 
 21334  
 
 21335  12
                     retval.tree = root_0;
 21336  
 
 21337  
                     }
 21338  12
                     break;
 21339  
                 case 34 :
 21340  
                     // com\\googlecode\\sparkleg\\Sparql.g:606:7: TZ '(' expression ')'
 21341  
                     {
 21342  12
                     TZ521=(Token)match(input,TZ,FOLLOW_TZ_in_builtInCall5998);  
 21343  12
                     stream_TZ.add(TZ521);
 21344  
 
 21345  
 
 21346  12
                     char_literal522=(Token)match(input,209,FOLLOW_209_in_builtInCall6000);  
 21347  12
                     stream_209.add(char_literal522);
 21348  
 
 21349  
 
 21350  12
                     pushFollow(FOLLOW_expression_in_builtInCall6002);
 21351  12
                     expression523=expression();
 21352  
 
 21353  12
                     state._fsp--;
 21354  
 
 21355  12
                     stream_expression.add(expression523.getTree());
 21356  
 
 21357  12
                     char_literal524=(Token)match(input,210,FOLLOW_210_in_builtInCall6004);  
 21358  12
                     stream_210.add(char_literal524);
 21359  
 
 21360  
 
 21361  
                     // AST REWRITE
 21362  
                     // elements: expression, TZ
 21363  
                     // token labels: 
 21364  
                     // rule labels: retval
 21365  
                     // token list labels: 
 21366  
                     // rule list labels: 
 21367  
                     // wildcard labels: 
 21368  12
                     retval.tree = root_0;
 21369  12
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21370  
 
 21371  12
                     root_0 = (Object)adaptor.nil();
 21372  
                     // 606:29: -> ^( TZ expression )
 21373  
                     {
 21374  
                         // com\\googlecode\\sparkleg\\Sparql.g:606:32: ^( TZ expression )
 21375  
                         {
 21376  12
                         Object root_1 = (Object)adaptor.nil();
 21377  12
                         root_1 = (Object)adaptor.becomeRoot(
 21378  
                         stream_TZ.nextNode()
 21379  
                         , root_1);
 21380  
 
 21381  12
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21382  
 
 21383  12
                         adaptor.addChild(root_0, root_1);
 21384  
                         }
 21385  
 
 21386  
                     }
 21387  
 
 21388  
 
 21389  12
                     retval.tree = root_0;
 21390  
 
 21391  
                     }
 21392  12
                     break;
 21393  
                 case 35 :
 21394  
                     // com\\googlecode\\sparkleg\\Sparql.g:607:7: NOW nil
 21395  
                     {
 21396  12
                     NOW525=(Token)match(input,NOW,FOLLOW_NOW_in_builtInCall6020);  
 21397  12
                     stream_NOW.add(NOW525);
 21398  
 
 21399  
 
 21400  12
                     pushFollow(FOLLOW_nil_in_builtInCall6022);
 21401  12
                     nil526=nil();
 21402  
 
 21403  8
                     state._fsp--;
 21404  4
 
 21405  12
                     stream_nil.add(nil526.getTree());
 21406  
 
 21407  4
                     // AST REWRITE
 21408  
                     // elements: NOW
 21409  4
                     // token labels: 
 21410  
                     // rule labels: retval
 21411  4
                     // token list labels: 
 21412  4
                     // rule list labels: 
 21413  
                     // wildcard labels: 
 21414  8
                     retval.tree = root_0;
 21415  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21416  
 
 21417  8
                     root_0 = (Object)adaptor.nil();
 21418  
                     // 607:15: -> NOW
 21419  
                     {
 21420  8
                         adaptor.addChild(root_0, 
 21421  
                         stream_NOW.nextNode()
 21422  4
                         );
 21423  4
 
 21424  
                     }
 21425  4
 
 21426  
 
 21427  8
                     retval.tree = root_0;
 21428  
 
 21429  
                     }
 21430  12
                     break;
 21431  4
                 case 36 :
 21432  
                     // com\\googlecode\\sparkleg\\Sparql.g:608:7: MD5 '(' expression ')'
 21433  
                     {
 21434  16
                     MD5527=(Token)match(input,MD5,FOLLOW_MD5_in_builtInCall6034);  
 21435  20
                     stream_MD5.add(MD5527);
 21436  
 
 21437  4
 
 21438  16
                     char_literal528=(Token)match(input,209,FOLLOW_209_in_builtInCall6036);  
 21439  16
                     stream_209.add(char_literal528);
 21440  
 
 21441  
 
 21442  16
                     pushFollow(FOLLOW_expression_in_builtInCall6038);
 21443  20
                     expression529=expression();
 21444  
 
 21445  16
                     state._fsp--;
 21446  4
 
 21447  16
                     stream_expression.add(expression529.getTree());
 21448  
 
 21449  16
                     char_literal530=(Token)match(input,210,FOLLOW_210_in_builtInCall6040);  
 21450  20
                     stream_210.add(char_literal530);
 21451  4
 
 21452  
 
 21453  
                     // AST REWRITE
 21454  4
                     // elements: expression, MD5
 21455  4
                     // token labels: 
 21456  
                     // rule labels: retval
 21457  
                     // token list labels: 
 21458  4
                     // rule list labels: 
 21459  4
                     // wildcard labels: 
 21460  16
                     retval.tree = root_0;
 21461  20
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21462  
 
 21463  20
                     root_0 = (Object)adaptor.nil();
 21464  
                     // 608:30: -> ^( MD5 expression )
 21465  4
                     {
 21466  4
                         // com\\googlecode\\sparkleg\\Sparql.g:608:33: ^( MD5 expression )
 21467  
                         {
 21468  16
                         Object root_1 = (Object)adaptor.nil();
 21469  16
                         root_1 = (Object)adaptor.becomeRoot(
 21470  
                         stream_MD5.nextNode()
 21471  
                         , root_1);
 21472  
 
 21473  16
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21474  
 
 21475  16
                         adaptor.addChild(root_0, root_1);
 21476  4
                         }
 21477  4
 
 21478  
                     }
 21479  4
 
 21480  
 
 21481  16
                     retval.tree = root_0;
 21482  
 
 21483  
                     }
 21484  20
                     break;
 21485  4
                 case 37 :
 21486  
                     // com\\googlecode\\sparkleg\\Sparql.g:609:7: SHA1 '(' expression ')'
 21487  
                     {
 21488  16
                     SHA1531=(Token)match(input,SHA1,FOLLOW_SHA1_in_builtInCall6056);  
 21489  20
                     stream_SHA1.add(SHA1531);
 21490  
 
 21491  4
 
 21492  16
                     char_literal532=(Token)match(input,209,FOLLOW_209_in_builtInCall6058);  
 21493  16
                     stream_209.add(char_literal532);
 21494  
 
 21495  
 
 21496  16
                     pushFollow(FOLLOW_expression_in_builtInCall6060);
 21497  20
                     expression533=expression();
 21498  
 
 21499  16
                     state._fsp--;
 21500  4
 
 21501  16
                     stream_expression.add(expression533.getTree());
 21502  
 
 21503  16
                     char_literal534=(Token)match(input,210,FOLLOW_210_in_builtInCall6062);  
 21504  28
                     stream_210.add(char_literal534);
 21505  12
 
 21506  
 
 21507  
                     // AST REWRITE
 21508  12
                     // elements: expression, SHA1
 21509  12
                     // token labels: 
 21510  
                     // rule labels: retval
 21511  12
                     // token list labels: 
 21512  
                     // rule list labels: 
 21513  12
                     // wildcard labels: 
 21514  16
                     retval.tree = root_0;
 21515  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21516  
 
 21517  16
                     root_0 = (Object)adaptor.nil();
 21518  
                     // 609:31: -> ^( SHA1 expression )
 21519  
                     {
 21520  
                         // com\\googlecode\\sparkleg\\Sparql.g:609:34: ^( SHA1 expression )
 21521  
                         {
 21522  28
                         Object root_1 = (Object)adaptor.nil();
 21523  28
                         root_1 = (Object)adaptor.becomeRoot(
 21524  
                         stream_SHA1.nextNode()
 21525  12
                         , root_1);
 21526  
 
 21527  16
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21528  
 
 21529  16
                         adaptor.addChild(root_0, root_1);
 21530  12
                         }
 21531  12
 
 21532  
                     }
 21533  
 
 21534  
 
 21535  28
                     retval.tree = root_0;
 21536  
 
 21537  12
                     }
 21538  16
                     break;
 21539  
                 case 38 :
 21540  
                     // com\\googlecode\\sparkleg\\Sparql.g:610:7: SHA256 '(' expression ')'
 21541  
                     {
 21542  16
                     SHA256535=(Token)match(input,SHA256,FOLLOW_SHA256_in_builtInCall6078);  
 21543  28
                     stream_SHA256.add(SHA256535);
 21544  
 
 21545  
 
 21546  28
                     char_literal536=(Token)match(input,209,FOLLOW_209_in_builtInCall6080);  
 21547  16
                     stream_209.add(char_literal536);
 21548  
 
 21549  
 
 21550  22
                     pushFollow(FOLLOW_expression_in_builtInCall6082);
 21551  22
                     expression537=expression();
 21552  
 
 21553  16
                     state._fsp--;
 21554  6
 
 21555  22
                     stream_expression.add(expression537.getTree());
 21556  
 
 21557  16
                     char_literal538=(Token)match(input,210,FOLLOW_210_in_builtInCall6084);  
 21558  22
                     stream_210.add(char_literal538);
 21559  6
 
 21560  
 
 21561  6
                     // AST REWRITE
 21562  
                     // elements: SHA256, expression
 21563  6
                     // token labels: 
 21564  
                     // rule labels: retval
 21565  6
                     // token list labels: 
 21566  6
                     // rule list labels: 
 21567  
                     // wildcard labels: 
 21568  16
                     retval.tree = root_0;
 21569  22
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21570  6
 
 21571  16
                     root_0 = (Object)adaptor.nil();
 21572  6
                     // 610:33: -> ^( SHA256 expression )
 21573  
                     {
 21574  6
                         // com\\googlecode\\sparkleg\\Sparql.g:610:36: ^( SHA256 expression )
 21575  
                         {
 21576  22
                         Object root_1 = (Object)adaptor.nil();
 21577  22
                         root_1 = (Object)adaptor.becomeRoot(
 21578  
                         stream_SHA256.nextNode()
 21579  
                         , root_1);
 21580  6
 
 21581  22
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21582  
 
 21583  22
                         adaptor.addChild(root_0, root_1);
 21584  
                         }
 21585  6
 
 21586  
                     }
 21587  6
 
 21588  6
 
 21589  16
                     retval.tree = root_0;
 21590  
 
 21591  
                     }
 21592  16
                     break;
 21593  
                 case 39 :
 21594  
                     // com\\googlecode\\sparkleg\\Sparql.g:611:7: SHA384 '(' expression ')'
 21595  
                     {
 21596  16
                     SHA384539=(Token)match(input,SHA384,FOLLOW_SHA384_in_builtInCall6100);  
 21597  16
                     stream_SHA384.add(SHA384539);
 21598  6
 
 21599  6
 
 21600  22
                     char_literal540=(Token)match(input,209,FOLLOW_209_in_builtInCall6102);  
 21601  22
                     stream_209.add(char_literal540);
 21602  6
 
 21603  
 
 21604  22
                     pushFollow(FOLLOW_expression_in_builtInCall6104);
 21605  16
                     expression541=expression();
 21606  
 
 21607  16
                     state._fsp--;
 21608  
 
 21609  22
                     stream_expression.add(expression541.getTree());
 21610  6
 
 21611  16
                     char_literal542=(Token)match(input,210,FOLLOW_210_in_builtInCall6106);  
 21612  16
                     stream_210.add(char_literal542);
 21613  
 
 21614  6
 
 21615  
                     // AST REWRITE
 21616  6
                     // elements: expression, SHA384
 21617  
                     // token labels: 
 21618  6
                     // rule labels: retval
 21619  
                     // token list labels: 
 21620  6
                     // rule list labels: 
 21621  
                     // wildcard labels: 
 21622  16
                     retval.tree = root_0;
 21623  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21624  
 
 21625  16
                     root_0 = (Object)adaptor.nil();
 21626  6
                     // 611:33: -> ^( SHA384 expression )
 21627  
                     {
 21628  
                         // com\\googlecode\\sparkleg\\Sparql.g:611:36: ^( SHA384 expression )
 21629  6
                         {
 21630  16
                         Object root_1 = (Object)adaptor.nil();
 21631  16
                         root_1 = (Object)adaptor.becomeRoot(
 21632  
                         stream_SHA384.nextNode()
 21633  6
                         , root_1);
 21634  6
 
 21635  16
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21636  
 
 21637  22
                         adaptor.addChild(root_0, root_1);
 21638  6
                         }
 21639  
 
 21640  
                     }
 21641  6
 
 21642  6
 
 21643  16
                     retval.tree = root_0;
 21644  6
 
 21645  
                     }
 21646  22
                     break;
 21647  
                 case 40 :
 21648  6
                     // com\\googlecode\\sparkleg\\Sparql.g:612:7: SHA512 '(' expression ')'
 21649  6
                     {
 21650  16
                     SHA512543=(Token)match(input,SHA512,FOLLOW_SHA512_in_builtInCall6122);  
 21651  16
                     stream_SHA512.add(SHA512543);
 21652  6
 
 21653  6
 
 21654  16
                     char_literal544=(Token)match(input,209,FOLLOW_209_in_builtInCall6124);  
 21655  22
                     stream_209.add(char_literal544);
 21656  
 
 21657  6
 
 21658  16
                     pushFollow(FOLLOW_expression_in_builtInCall6126);
 21659  22
                     expression545=expression();
 21660  6
 
 21661  16
                     state._fsp--;
 21662  
 
 21663  16
                     stream_expression.add(expression545.getTree());
 21664  
 
 21665  16
                     char_literal546=(Token)match(input,210,FOLLOW_210_in_builtInCall6128);  
 21666  16
                     stream_210.add(char_literal546);
 21667  
 
 21668  
 
 21669  
                     // AST REWRITE
 21670  6
                     // elements: expression, SHA512
 21671  6
                     // token labels: 
 21672  
                     // rule labels: retval
 21673  6
                     // token list labels: 
 21674  
                     // rule list labels: 
 21675  
                     // wildcard labels: 
 21676  16
                     retval.tree = root_0;
 21677  16
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21678  6
 
 21679  22
                     root_0 = (Object)adaptor.nil();
 21680  
                     // 612:33: -> ^( SHA512 expression )
 21681  
                     {
 21682  
                         // com\\googlecode\\sparkleg\\Sparql.g:612:36: ^( SHA512 expression )
 21683  6
                         {
 21684  16
                         Object root_1 = (Object)adaptor.nil();
 21685  22
                         root_1 = (Object)adaptor.becomeRoot(
 21686  
                         stream_SHA512.nextNode()
 21687  6
                         , root_1);
 21688  
 
 21689  16
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21690  
 
 21691  16
                         adaptor.addChild(root_0, root_1);
 21692  
                         }
 21693  6
 
 21694  
                     }
 21695  
 
 21696  6
 
 21697  16
                     retval.tree = root_0;
 21698  
 
 21699  
                     }
 21700  22
                     break;
 21701  6
                 case 41 :
 21702  
                     // com\\googlecode\\sparkleg\\Sparql.g:613:7: COALESCE expressionList
 21703  
                     {
 21704  54
                     COALESCE547=(Token)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall6144);  
 21705  54
                     stream_COALESCE.add(COALESCE547);
 21706  
 
 21707  
 
 21708  54
                     pushFollow(FOLLOW_expressionList_in_builtInCall6146);
 21709  54
                     expressionList548=expressionList();
 21710  
 
 21711  54
                     state._fsp--;
 21712  
 
 21713  54
                     stream_expressionList.add(expressionList548.getTree());
 21714  
 
 21715  6
                     // AST REWRITE
 21716  6
                     // elements: COALESCE, expressionList
 21717  
                     // token labels: 
 21718  
                     // rule labels: retval
 21719  6
                     // token list labels: 
 21720  6
                     // rule list labels: 
 21721  
                     // wildcard labels: 
 21722  54
                     retval.tree = root_0;
 21723  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21724  6
 
 21725  48
                     root_0 = (Object)adaptor.nil();
 21726  6
                     // 613:31: -> ^( COALESCE expressionList )
 21727  6
                     {
 21728  
                         // com\\googlecode\\sparkleg\\Sparql.g:613:34: ^( COALESCE expressionList )
 21729  
                         {
 21730  48
                         Object root_1 = (Object)adaptor.nil();
 21731  48
                         root_1 = (Object)adaptor.becomeRoot(
 21732  
                         stream_COALESCE.nextNode()
 21733  
                         , root_1);
 21734  
 
 21735  48
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 21736  
 
 21737  54
                         adaptor.addChild(root_0, root_1);
 21738  6
                         }
 21739  
 
 21740  6
                     }
 21741  
 
 21742  
 
 21743  48
                     retval.tree = root_0;
 21744  
 
 21745  6
                     }
 21746  54
                     break;
 21747  
                 case 42 :
 21748  
                     // com\\googlecode\\sparkleg\\Sparql.g:614:7: IF '(' e1= expression ',' e2= expression ',' e3= expression ')'
 21749  
                     {
 21750  30
                     IF549=(Token)match(input,IF,FOLLOW_IF_in_builtInCall6162);  
 21751  24
                     stream_IF.add(IF549);
 21752  6
 
 21753  
 
 21754  30
                     char_literal550=(Token)match(input,209,FOLLOW_209_in_builtInCall6164);  
 21755  24
                     stream_209.add(char_literal550);
 21756  
 
 21757  
 
 21758  24
                     pushFollow(FOLLOW_expression_in_builtInCall6168);
 21759  24
                     e1=expression();
 21760  6
 
 21761  24
                     state._fsp--;
 21762  
 
 21763  30
                     stream_expression.add(e1.getTree());
 21764  
 
 21765  24
                     char_literal551=(Token)match(input,211,FOLLOW_211_in_builtInCall6170);  
 21766  24
                     stream_211.add(char_literal551);
 21767  30
 
 21768  30
 
 21769  24
                     pushFollow(FOLLOW_expression_in_builtInCall6174);
 21770  24
                     e2=expression();
 21771  30
 
 21772  54
                     state._fsp--;
 21773  
 
 21774  24
                     stream_expression.add(e2.getTree());
 21775  30
 
 21776  54
                     char_literal552=(Token)match(input,211,FOLLOW_211_in_builtInCall6176);  
 21777  24
                     stream_211.add(char_literal552);
 21778  30
 
 21779  
 
 21780  54
                     pushFollow(FOLLOW_expression_in_builtInCall6180);
 21781  24
                     e3=expression();
 21782  30
 
 21783  54
                     state._fsp--;
 21784  
 
 21785  24
                     stream_expression.add(e3.getTree());
 21786  30
 
 21787  54
                     char_literal553=(Token)match(input,210,FOLLOW_210_in_builtInCall6182);  
 21788  24
                     stream_210.add(char_literal553);
 21789  30
 
 21790  
 
 21791  30
                     // AST REWRITE
 21792  
                     // elements: e3, e2, e1, IF
 21793  30
                     // token labels: 
 21794  30
                     // rule labels: e3, retval, e1, e2
 21795  
                     // token list labels: 
 21796  
                     // rule list labels: 
 21797  
                     // wildcard labels: 
 21798  24
                     retval.tree = root_0;
 21799  24
                     RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
 21800  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21801  24
                     RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 21802  24
                     RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 21803  
 
 21804  54
                     root_0 = (Object)adaptor.nil();
 21805  30
                     // 614:68: -> ^( IF $e1 $e2 $e3)
 21806  
                     {
 21807  30
                         // com\\googlecode\\sparkleg\\Sparql.g:614:71: ^( IF $e1 $e2 $e3)
 21808  
                         {
 21809  24
                         Object root_1 = (Object)adaptor.nil();
 21810  24
                         root_1 = (Object)adaptor.becomeRoot(
 21811  
                         stream_IF.nextNode()
 21812  30
                         , root_1);
 21813  30
 
 21814  24
                         adaptor.addChild(root_1, stream_e1.nextTree());
 21815  
 
 21816  24
                         adaptor.addChild(root_1, stream_e2.nextTree());
 21817  30
 
 21818  24
                         adaptor.addChild(root_1, stream_e3.nextTree());
 21819  30
 
 21820  24
                         adaptor.addChild(root_0, root_1);
 21821  30
                         }
 21822  
 
 21823  
                     }
 21824  
 
 21825  
 
 21826  24
                     retval.tree = root_0;
 21827  30
 
 21828  
                     }
 21829  24
                     break;
 21830  30
                 case 43 :
 21831  
                     // com\\googlecode\\sparkleg\\Sparql.g:615:7: STRLANG '(' expression ',' expression ')'
 21832  
                     {
 21833  24
                     STRLANG554=(Token)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall6205);  
 21834  32
                     stream_STRLANG.add(STRLANG554);
 21835  8
 
 21836  
 
 21837  24
                     char_literal555=(Token)match(input,209,FOLLOW_209_in_builtInCall6207);  
 21838  32
                     stream_209.add(char_literal555);
 21839  8
 
 21840  
 
 21841  24
                     pushFollow(FOLLOW_expression_in_builtInCall6209);
 21842  32
                     expression556=expression();
 21843  8
 
 21844  24
                     state._fsp--;
 21845  8
 
 21846  24
                     stream_expression.add(expression556.getTree());
 21847  8
 
 21848  24
                     char_literal557=(Token)match(input,211,FOLLOW_211_in_builtInCall6211);  
 21849  32
                     stream_211.add(char_literal557);
 21850  8
 
 21851  
 
 21852  24
                     pushFollow(FOLLOW_expression_in_builtInCall6213);
 21853  24
                     expression558=expression();
 21854  
 
 21855  24
                     state._fsp--;
 21856  
 
 21857  24
                     stream_expression.add(expression558.getTree());
 21858  
 
 21859  24
                     char_literal559=(Token)match(input,210,FOLLOW_210_in_builtInCall6215);  
 21860  32
                     stream_210.add(char_literal559);
 21861  8
 
 21862  
 
 21863  8
                     // AST REWRITE
 21864  
                     // elements: STRLANG, expression, expression
 21865  
                     // token labels: 
 21866  
                     // rule labels: retval
 21867  
                     // token list labels: 
 21868  8
                     // rule list labels: 
 21869  8
                     // wildcard labels: 
 21870  24
                     retval.tree = root_0;
 21871  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21872  
 
 21873  32
                     root_0 = (Object)adaptor.nil();
 21874  
                     // 615:49: -> ^( STRLANG expression expression )
 21875  8
                     {
 21876  
                         // com\\googlecode\\sparkleg\\Sparql.g:615:52: ^( STRLANG expression expression )
 21877  
                         {
 21878  24
                         Object root_1 = (Object)adaptor.nil();
 21879  24
                         root_1 = (Object)adaptor.becomeRoot(
 21880  
                         stream_STRLANG.nextNode()
 21881  8
                         , root_1);
 21882  
 
 21883  24
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21884  8
 
 21885  24
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21886  
 
 21887  24
                         adaptor.addChild(root_0, root_1);
 21888  2
                         }
 21889  2
 
 21890  
                     }
 21891  
 
 21892  2
 
 21893  26
                     retval.tree = root_0;
 21894  
 
 21895  
                     }
 21896  26
                     break;
 21897  2
                 case 44 :
 21898  
                     // com\\googlecode\\sparkleg\\Sparql.g:616:7: STRDT '(' expression ',' expression ')'
 21899  2
                     {
 21900  24
                     STRDT560=(Token)match(input,STRDT,FOLLOW_STRDT_in_builtInCall6233);  
 21901  26
                     stream_STRDT.add(STRDT560);
 21902  
 
 21903  2
 
 21904  26
                     char_literal561=(Token)match(input,209,FOLLOW_209_in_builtInCall6235);  
 21905  24
                     stream_209.add(char_literal561);
 21906  
 
 21907  
 
 21908  24
                     pushFollow(FOLLOW_expression_in_builtInCall6237);
 21909  24
                     expression562=expression();
 21910  
 
 21911  24
                     state._fsp--;
 21912  
 
 21913  24
                     stream_expression.add(expression562.getTree());
 21914  2
 
 21915  26
                     char_literal563=(Token)match(input,211,FOLLOW_211_in_builtInCall6239);  
 21916  24
                     stream_211.add(char_literal563);
 21917  2
 
 21918  
 
 21919  24
                     pushFollow(FOLLOW_expression_in_builtInCall6241);
 21920  24
                     expression564=expression();
 21921  
 
 21922  26
                     state._fsp--;
 21923  2
 
 21924  24
                     stream_expression.add(expression564.getTree());
 21925  
 
 21926  24
                     char_literal565=(Token)match(input,210,FOLLOW_210_in_builtInCall6243);  
 21927  26
                     stream_210.add(char_literal565);
 21928  
 
 21929  2
 
 21930  
                     // AST REWRITE
 21931  
                     // elements: STRDT, expression, expression
 21932  
                     // token labels: 
 21933  
                     // rule labels: retval
 21934  
                     // token list labels: 
 21935  2
                     // rule list labels: 
 21936  
                     // wildcard labels: 
 21937  24
                     retval.tree = root_0;
 21938  26
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21939  
 
 21940  24
                     root_0 = (Object)adaptor.nil();
 21941  
                     // 616:47: -> ^( STRDT expression expression )
 21942  8
                     {
 21943  8
                         // com\\googlecode\\sparkleg\\Sparql.g:616:50: ^( STRDT expression expression )
 21944  
                         {
 21945  24
                         Object root_1 = (Object)adaptor.nil();
 21946  32
                         root_1 = (Object)adaptor.becomeRoot(
 21947  8
                         stream_STRDT.nextNode()
 21948  
                         , root_1);
 21949  
 
 21950  32
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21951  8
 
 21952  24
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21953  8
 
 21954  24
                         adaptor.addChild(root_0, root_1);
 21955  8
                         }
 21956  
 
 21957  8
                     }
 21958  8
 
 21959  
 
 21960  24
                     retval.tree = root_0;
 21961  
 
 21962  
                     }
 21963  24
                     break;
 21964  
                 case 45 :
 21965  
                     // com\\googlecode\\sparkleg\\Sparql.g:617:7: SAMETERM '(' expression ',' expression ')'
 21966  
                     {
 21967  120
                     SAMETERM566=(Token)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall6261);  
 21968  128
                     stream_SAMETERM.add(SAMETERM566);
 21969  8
 
 21970  
 
 21971  128
                     char_literal567=(Token)match(input,209,FOLLOW_209_in_builtInCall6263);  
 21972  120
                     stream_209.add(char_literal567);
 21973  
 
 21974  
 
 21975  120
                     pushFollow(FOLLOW_expression_in_builtInCall6265);
 21976  128
                     expression568=expression();
 21977  8
 
 21978  120
                     state._fsp--;
 21979  
 
 21980  120
                     stream_expression.add(expression568.getTree());
 21981  8
 
 21982  120
                     char_literal569=(Token)match(input,211,FOLLOW_211_in_builtInCall6267);  
 21983  128
                     stream_211.add(char_literal569);
 21984  
 
 21985  
 
 21986  120
                     pushFollow(FOLLOW_expression_in_builtInCall6269);
 21987  120
                     expression570=expression();
 21988  
 
 21989  128
                     state._fsp--;
 21990  
 
 21991  120
                     stream_expression.add(expression570.getTree());
 21992  8
 
 21993  120
                     char_literal571=(Token)match(input,210,FOLLOW_210_in_builtInCall6271);  
 21994  120
                     stream_210.add(char_literal571);
 21995  
 
 21996  8
 
 21997  8
                     // AST REWRITE
 21998  
                     // elements: expression, expression, SAMETERM
 21999  
                     // token labels: 
 22000  8
                     // rule labels: retval
 22001  8
                     // token list labels: 
 22002  
                     // rule list labels: 
 22003  
                     // wildcard labels: 
 22004  128
                     retval.tree = root_0;
 22005  128
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22006  
 
 22007  128
                     root_0 = (Object)adaptor.nil();
 22008  
                     // 617:50: -> ^( SAMETERM expression expression )
 22009  8
                     {
 22010  
                         // com\\googlecode\\sparkleg\\Sparql.g:617:53: ^( SAMETERM expression expression )
 22011  8
                         {
 22012  128
                         Object root_1 = (Object)adaptor.nil();
 22013  120
                         root_1 = (Object)adaptor.becomeRoot(
 22014  
                         stream_SAMETERM.nextNode()
 22015  
                         , root_1);
 22016  
 
 22017  120
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22018  
 
 22019  120
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22020  
 
 22021  120
                         adaptor.addChild(root_0, root_1);
 22022  8
                         }
 22023  8
 
 22024  
                     }
 22025  8
 
 22026  
 
 22027  120
                     retval.tree = root_0;
 22028  
 
 22029  
                     }
 22030  128
                     break;
 22031  8
                 case 46 :
 22032  
                     // com\\googlecode\\sparkleg\\Sparql.g:618:7: ISIRI '(' expression ')'
 22033  
                     {
 22034  32
                     ISIRI572=(Token)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall6289);  
 22035  40
                     stream_ISIRI.add(ISIRI572);
 22036  
 
 22037  8
 
 22038  32
                     char_literal573=(Token)match(input,209,FOLLOW_209_in_builtInCall6291);  
 22039  32
                     stream_209.add(char_literal573);
 22040  
 
 22041  
 
 22042  32
                     pushFollow(FOLLOW_expression_in_builtInCall6293);
 22043  40
                     expression574=expression();
 22044  
 
 22045  32
                     state._fsp--;
 22046  8
 
 22047  32
                     stream_expression.add(expression574.getTree());
 22048  
 
 22049  32
                     char_literal575=(Token)match(input,210,FOLLOW_210_in_builtInCall6295);  
 22050  36
                     stream_210.add(char_literal575);
 22051  4
 
 22052  
 
 22053  
                     // AST REWRITE
 22054  4
                     // elements: expression, ISIRI
 22055  4
                     // token labels: 
 22056  
                     // rule labels: retval
 22057  
                     // token list labels: 
 22058  4
                     // rule list labels: 
 22059  4
                     // wildcard labels: 
 22060  32
                     retval.tree = root_0;
 22061  36
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22062  
 
 22063  36
                     root_0 = (Object)adaptor.nil();
 22064  
                     // 618:32: -> ^( ISIRI expression )
 22065  4
                     {
 22066  4
                         // com\\googlecode\\sparkleg\\Sparql.g:618:35: ^( ISIRI expression )
 22067  
                         {
 22068  32
                         Object root_1 = (Object)adaptor.nil();
 22069  32
                         root_1 = (Object)adaptor.becomeRoot(
 22070  
                         stream_ISIRI.nextNode()
 22071  
                         , root_1);
 22072  
 
 22073  32
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22074  
 
 22075  32
                         adaptor.addChild(root_0, root_1);
 22076  4
                         }
 22077  4
 
 22078  
                     }
 22079  4
 
 22080  
 
 22081  32
                     retval.tree = root_0;
 22082  
 
 22083  
                     }
 22084  36
                     break;
 22085  4
                 case 47 :
 22086  
                     // com\\googlecode\\sparkleg\\Sparql.g:619:7: ISURI '(' expression ')'
 22087  
                     {
 22088  8
                     ISURI576=(Token)match(input,ISURI,FOLLOW_ISURI_in_builtInCall6311);  
 22089  12
                     stream_ISURI.add(ISURI576);
 22090  
 
 22091  4
 
 22092  8
                     char_literal577=(Token)match(input,209,FOLLOW_209_in_builtInCall6313);  
 22093  8
                     stream_209.add(char_literal577);
 22094  
 
 22095  
 
 22096  8
                     pushFollow(FOLLOW_expression_in_builtInCall6315);
 22097  12
                     expression578=expression();
 22098  
 
 22099  8
                     state._fsp--;
 22100  4
 
 22101  8
                     stream_expression.add(expression578.getTree());
 22102  
 
 22103  8
                     char_literal579=(Token)match(input,210,FOLLOW_210_in_builtInCall6317);  
 22104  50
                     stream_210.add(char_literal579);
 22105  42
 
 22106  
 
 22107  42
                     // AST REWRITE
 22108  
                     // elements: expression, ISURI
 22109  42
                     // token labels: 
 22110  
                     // rule labels: retval
 22111  
                     // token list labels: 
 22112  
                     // rule list labels: 
 22113  
                     // wildcard labels: 
 22114  8
                     retval.tree = root_0;
 22115  8
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22116  
 
 22117  8
                     root_0 = (Object)adaptor.nil();
 22118  42
                     // 619:32: -> ^( ISURI expression )
 22119  42
                     {
 22120  
                         // com\\googlecode\\sparkleg\\Sparql.g:619:35: ^( ISURI expression )
 22121  42
                         {
 22122  8
                         Object root_1 = (Object)adaptor.nil();
 22123  8
                         root_1 = (Object)adaptor.becomeRoot(
 22124  42
                         stream_ISURI.nextNode()
 22125  
                         , root_1);
 22126  
 
 22127  8
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22128  
 
 22129  50
                         adaptor.addChild(root_0, root_1);
 22130  
                         }
 22131  
 
 22132  42
                     }
 22133  
 
 22134  
 
 22135  8
                     retval.tree = root_0;
 22136  20
 
 22137  20
                     }
 22138  8
                     break;
 22139  20
                 case 48 :
 22140  
                     // com\\googlecode\\sparkleg\\Sparql.g:620:7: ISBLANK '(' expression ')'
 22141  20
                     {
 22142  32
                     ISBLANK580=(Token)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall6333);  
 22143  32
                     stream_ISBLANK.add(ISBLANK580);
 22144  
 
 22145  
 
 22146  32
                     char_literal581=(Token)match(input,209,FOLLOW_209_in_builtInCall6335);  
 22147  32
                     stream_209.add(char_literal581);
 22148  
 
 22149  
 
 22150  52
                     pushFollow(FOLLOW_expression_in_builtInCall6337);
 22151  52
                     expression582=expression();
 22152  
 
 22153  52
                     state._fsp--;
 22154  
 
 22155  32
                     stream_expression.add(expression582.getTree());
 22156  20
 
 22157  32
                     char_literal583=(Token)match(input,210,FOLLOW_210_in_builtInCall6339);  
 22158  32
                     stream_210.add(char_literal583);
 22159  
 
 22160  
 
 22161  20
                     // AST REWRITE
 22162  
                     // elements: ISBLANK, expression
 22163  
                     // token labels: 
 22164  20
                     // rule labels: retval
 22165  
                     // token list labels: 
 22166  
                     // rule list labels: 
 22167  
                     // wildcard labels: 
 22168  78
                     retval.tree = root_0;
 22169  78
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22170  
 
 22171  78
                     root_0 = (Object)adaptor.nil();
 22172  
                     // 620:34: -> ^( ISBLANK expression )
 22173  46
                     {
 22174  
                         // com\\googlecode\\sparkleg\\Sparql.g:620:37: ^( ISBLANK expression )
 22175  
                         {
 22176  32
                         Object root_1 = (Object)adaptor.nil();
 22177  32
                         root_1 = (Object)adaptor.becomeRoot(
 22178  
                         stream_ISBLANK.nextNode()
 22179  
                         , root_1);
 22180  
 
 22181  32
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22182  46
 
 22183  78
                         adaptor.addChild(root_0, root_1);
 22184  
                         }
 22185  46
 
 22186  
                     }
 22187  
 
 22188  46
 
 22189  32
                     retval.tree = root_0;
 22190  
 
 22191  
                     }
 22192  32
                     break;
 22193  46
                 case 49 :
 22194  
                     // com\\googlecode\\sparkleg\\Sparql.g:621:7: ISLITERAL '(' expression ')'
 22195  
                     {
 22196  32
                     ISLITERAL584=(Token)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall6356);  
 22197  32
                     stream_ISLITERAL.add(ISLITERAL584);
 22198  
 
 22199  532
 
 22200  32
                     char_literal585=(Token)match(input,209,FOLLOW_209_in_builtInCall6358);  
 22201  32
                     stream_209.add(char_literal585);
 22202  532
 
 22203  532
 
 22204  32
                     pushFollow(FOLLOW_expression_in_builtInCall6360);
 22205  32
                     expression586=expression();
 22206  
 
 22207  32
                     state._fsp--;
 22208  
 
 22209  32
                     stream_expression.add(expression586.getTree());
 22210  
 
 22211  32
                     char_literal587=(Token)match(input,210,FOLLOW_210_in_builtInCall6362);  
 22212  32
                     stream_210.add(char_literal587);
 22213  
 
 22214  
 
 22215  532
                     // AST REWRITE
 22216  532
                     // elements: ISLITERAL, expression
 22217  
                     // token labels: 
 22218  
                     // rule labels: retval
 22219  
                     // token list labels: 
 22220  
                     // rule list labels: 
 22221  42
                     // wildcard labels: 
 22222  32
                     retval.tree = root_0;
 22223  32
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22224  
 
 22225  32
                     root_0 = (Object)adaptor.nil();
 22226  
                     // 621:36: -> ^( ISLITERAL expression )
 22227  
                     {
 22228  
                         // com\\googlecode\\sparkleg\\Sparql.g:621:39: ^( ISLITERAL expression )
 22229  
                         {
 22230  74
                         Object root_1 = (Object)adaptor.nil();
 22231  74
                         root_1 = (Object)adaptor.becomeRoot(
 22232  
                         stream_ISLITERAL.nextNode()
 22233  
                         , root_1);
 22234  42
 
 22235  32
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22236  42
 
 22237  74
                         adaptor.addChild(root_0, root_1);
 22238  42
                         }
 22239  42
 
 22240  42
                     }
 22241  42
 
 22242  
 
 22243  74
                     retval.tree = root_0;
 22244  
 
 22245  42
                     }
 22246  32
                     break;
 22247  
                 case 50 :
 22248  42
                     // com\\googlecode\\sparkleg\\Sparql.g:622:7: ISNUMERIC '(' expression ')'
 22249  42
                     {
 22250  58
                     ISNUMERIC588=(Token)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall6378);  
 22251  58
                     stream_ISNUMERIC.add(ISNUMERIC588);
 22252  42
 
 22253  42
 
 22254  58
                     char_literal589=(Token)match(input,209,FOLLOW_209_in_builtInCall6380);  
 22255  58
                     stream_209.add(char_literal589);
 22256  42
 
 22257  42
 
 22258  16
                     pushFollow(FOLLOW_expression_in_builtInCall6382);
 22259  16
                     expression590=expression();
 22260  
 
 22261  16
                     state._fsp--;
 22262  42
 
 22263  58
                     stream_expression.add(expression590.getTree());
 22264  
 
 22265  16
                     char_literal591=(Token)match(input,210,FOLLOW_210_in_builtInCall6384);  
 22266  58
                     stream_210.add(char_literal591);
 22267  42
 
 22268  
 
 22269  
                     // AST REWRITE
 22270  42
                     // elements: ISNUMERIC, expression
 22271  42
                     // token labels: 
 22272  
                     // rule labels: retval
 22273  42
                     // token list labels: 
 22274  
                     // rule list labels: 
 22275  42
                     // wildcard labels: 
 22276  16
                     retval.tree = root_0;
 22277  58
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22278  42
 
 22279  16
                     root_0 = (Object)adaptor.nil();
 22280  
                     // 622:36: -> ^( ISNUMERIC expression )
 22281  42
                     {
 22282  42
                         // com\\googlecode\\sparkleg\\Sparql.g:622:39: ^( ISNUMERIC expression )
 22283  
                         {
 22284  58
                         Object root_1 = (Object)adaptor.nil();
 22285  16
                         root_1 = (Object)adaptor.becomeRoot(
 22286  42
                         stream_ISNUMERIC.nextNode()
 22287  
                         , root_1);
 22288  
 
 22289  58
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22290  42
 
 22291  16
                         adaptor.addChild(root_0, root_1);
 22292  
                         }
 22293  12
 
 22294  
                     }
 22295  
 
 22296  
 
 22297  16
                     retval.tree = root_0;
 22298  42
 
 22299  
                     }
 22300  16
                     break;
 22301  
                 case 51 :
 22302  12
                     // com\\googlecode\\sparkleg\\Sparql.g:623:7: regexExpression
 22303  12
                     {
 22304  168
                     pushFollow(FOLLOW_regexExpression_in_builtInCall6400);
 22305  168
                     regexExpression592=regexExpression();
 22306  12
 
 22307  180
                     state._fsp--;
 22308  
 
 22309  180
                     stream_regexExpression.add(regexExpression592.getTree());
 22310  
 
 22311  12
                     // AST REWRITE
 22312  
                     // elements: regexExpression
 22313  
                     // token labels: 
 22314  
                     // rule labels: retval
 22315  
                     // token list labels: 
 22316  
                     // rule list labels: 
 22317  
                     // wildcard labels: 
 22318  168
                     retval.tree = root_0;
 22319  210
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22320  42
 
 22321  168
                     root_0 = (Object)adaptor.nil();
 22322  
                     // 623:23: -> regexExpression
 22323  
                     {
 22324  168
                         adaptor.addChild(root_0, stream_regexExpression.nextTree());
 22325  
 
 22326  
                     }
 22327  
 
 22328  
 
 22329  168
                     retval.tree = root_0;
 22330  42
 
 22331  42
                     }
 22332  168
                     break;
 22333  42
                 case 52 :
 22334  
                     // com\\googlecode\\sparkleg\\Sparql.g:624:7: existsFunction
 22335  
                     {
 22336  80
                     pushFollow(FOLLOW_existsFunction_in_builtInCall6412);
 22337  80
                     existsFunction593=existsFunction();
 22338  42
 
 22339  122
                     state._fsp--;
 22340  
 
 22341  80
                     stream_existsFunction.add(existsFunction593.getTree());
 22342  
 
 22343  
                     // AST REWRITE
 22344  138
                     // elements: existsFunction
 22345  96
                     // token labels: 
 22346  
                     // rule labels: retval
 22347  
                     // token list labels: 
 22348  42
                     // rule list labels: 
 22349  
                     // wildcard labels: 
 22350  122
                     retval.tree = root_0;
 22351  80
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22352  
 
 22353  80
                     root_0 = (Object)adaptor.nil();
 22354  
                     // 624:22: -> existsFunction
 22355  
                     {
 22356  122
                         adaptor.addChild(root_0, stream_existsFunction.nextTree());
 22357  
 
 22358  
                     }
 22359  
 
 22360  42
 
 22361  80
                     retval.tree = root_0;
 22362  
 
 22363  42
                     }
 22364  122
                     break;
 22365  
                 case 53 :
 22366  
                     // com\\googlecode\\sparkleg\\Sparql.g:625:7: notExistsFunction
 22367  
                     {
 22368  184
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall6424);
 22369  184
                     notExistsFunction594=notExistsFunction();
 22370  
 
 22371  184
                     state._fsp--;
 22372  
 
 22373  184
                     stream_notExistsFunction.add(notExistsFunction594.getTree());
 22374  
 
 22375  
                     // AST REWRITE
 22376  42
                     // elements: notExistsFunction
 22377  42
                     // token labels: 
 22378  
                     // rule labels: retval
 22379  
                     // token list labels: 
 22380  
                     // rule list labels: 
 22381  
                     // wildcard labels: 
 22382  4
                     retval.tree = root_0;
 22383  184
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22384  4
 
 22385  184
                     root_0 = (Object)adaptor.nil();
 22386  
                     // 625:25: -> notExistsFunction
 22387  
                     {
 22388  184
                         adaptor.addChild(root_0, stream_notExistsFunction.nextTree());
 22389  
 
 22390  
                     }
 22391  4
 
 22392  4
 
 22393  184
                     retval.tree = root_0;
 22394  
 
 22395  4
                     }
 22396  
                     break;
 22397  4
 
 22398  4
             }
 22399  2132
             retval.stop = input.LT(-1);
 22400  4
 
 22401  4
 
 22402  2132
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22403  2128
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22404  4
 
 22405  
         }
 22406  4
         catch (RecognitionException re) {
 22407  0
             reportError(re);
 22408  0
             recover(input,re);
 22409  4
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22410  4
 
 22411  4
         }
 22412  4
 
 22413  4
         finally {
 22414  4
                 // do for sure before leaving
 22415  2132
         }
 22416  2132
         return retval;
 22417  4
     }
 22418  4
     // $ANTLR end "builtInCall"
 22419  
 
 22420  
 
 22421  168
     public static class regexExpression_return extends ParserRuleReturnScope {
 22422  
         Object tree;
 22423  4
         public Object getTree() { return tree; }
 22424  4
     };
 22425  
 
 22426  
 
 22427  4
     // $ANTLR start "regexExpression"
 22428  4
     // com\\googlecode\\sparkleg\\Sparql.g:628:1: regexExpression : REGEX '(' expression ',' expression ( ',' expression )? ')' -> ^( REGEX ( expression )* ) ;
 22429  
     public final SparqlParser.regexExpression_return regexExpression() throws RecognitionException {
 22430  168
         SparqlParser.regexExpression_return retval = new SparqlParser.regexExpression_return();
 22431  172
         retval.start = input.LT(1);
 22432  4
 
 22433  
 
 22434  172
         Object root_0 = null;
 22435  
 
 22436  172
         Token REGEX595=null;
 22437  168
         Token char_literal596=null;
 22438  172
         Token char_literal598=null;
 22439  172
         Token char_literal600=null;
 22440  168
         Token char_literal602=null;
 22441  168
         SparqlParser.expression_return expression597 =null;
 22442  4
 
 22443  172
         SparqlParser.expression_return expression599 =null;
 22444  
 
 22445  172
         SparqlParser.expression_return expression601 =null;
 22446  
 
 22447  4
 
 22448  168
         Object REGEX595_tree=null;
 22449  168
         Object char_literal596_tree=null;
 22450  172
         Object char_literal598_tree=null;
 22451  172
         Object char_literal600_tree=null;
 22452  168
         Object char_literal602_tree=null;
 22453  168
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 22454  170
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 22455  168
         RewriteRuleTokenStream stream_REGEX=new RewriteRuleTokenStream(adaptor,"token REGEX");
 22456  168
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 22457  168
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22458  
         try {
 22459  4
             // com\\googlecode\\sparkleg\\Sparql.g:629:5: ( REGEX '(' expression ',' expression ( ',' expression )? ')' -> ^( REGEX ( expression )* ) )
 22460  
             // com\\googlecode\\sparkleg\\Sparql.g:629:7: REGEX '(' expression ',' expression ( ',' expression )? ')'
 22461  
             {
 22462  168
             REGEX595=(Token)match(input,REGEX,FOLLOW_REGEX_in_regexExpression6445);  
 22463  170
             stream_REGEX.add(REGEX595);
 22464  2
 
 22465  
 
 22466  168
             char_literal596=(Token)match(input,209,FOLLOW_209_in_regexExpression6447);  
 22467  170
             stream_209.add(char_literal596);
 22468  2
 
 22469  
 
 22470  170
             pushFollow(FOLLOW_expression_in_regexExpression6449);
 22471  168
             expression597=expression();
 22472  2
 
 22473  168
             state._fsp--;
 22474  
 
 22475  168
             stream_expression.add(expression597.getTree());
 22476  
 
 22477  168
             char_literal598=(Token)match(input,211,FOLLOW_211_in_regexExpression6451);  
 22478  168
             stream_211.add(char_literal598);
 22479  
 
 22480  4
 
 22481  172
             pushFollow(FOLLOW_expression_in_regexExpression6453);
 22482  168
             expression599=expression();
 22483  
 
 22484  168
             state._fsp--;
 22485  
 
 22486  168
             stream_expression.add(expression599.getTree());
 22487  
 
 22488  
             // com\\googlecode\\sparkleg\\Sparql.g:629:43: ( ',' expression )?
 22489  168
             int alt125=2;
 22490  168
             switch ( input.LA(1) ) {
 22491  4
                 case 211:
 22492  4
                     {
 22493  48
                     alt125=1;
 22494  4
                     }
 22495  
                     break;
 22496  
             }
 22497  
 
 22498  168
             switch (alt125) {
 22499  4
                 case 1 :
 22500  4
                     // com\\googlecode\\sparkleg\\Sparql.g:629:44: ',' expression
 22501  
                     {
 22502  48
                     char_literal600=(Token)match(input,211,FOLLOW_211_in_regexExpression6456);  
 22503  48
                     stream_211.add(char_literal600);
 22504  
 
 22505  14
 
 22506  58
                     pushFollow(FOLLOW_expression_in_regexExpression6458);
 22507  48
                     expression601=expression();
 22508  
 
 22509  52
                     state._fsp--;
 22510  
 
 22511  52
                     stream_expression.add(expression601.getTree());
 22512  
 
 22513  
                     }
 22514  
                     break;
 22515  
 
 22516  
             }
 22517  4
 
 22518  
 
 22519  168
             char_literal602=(Token)match(input,210,FOLLOW_210_in_regexExpression6462);  
 22520  168
             stream_210.add(char_literal602);
 22521  4
 
 22522  
 
 22523  
             // AST REWRITE
 22524  4
             // elements: expression, REGEX
 22525  4
             // token labels: 
 22526  
             // rule labels: retval
 22527  
             // token list labels: 
 22528  
             // rule list labels: 
 22529  
             // wildcard labels: 
 22530  168
             retval.tree = root_0;
 22531  168
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22532  
 
 22533  168
             root_0 = (Object)adaptor.nil();
 22534  
             // 629:65: -> ^( REGEX ( expression )* )
 22535  
             {
 22536  
                 // com\\googlecode\\sparkleg\\Sparql.g:629:68: ^( REGEX ( expression )* )
 22537  4
                 {
 22538  172
                 Object root_1 = (Object)adaptor.nil();
 22539  168
                 root_1 = (Object)adaptor.becomeRoot(
 22540  
                 stream_REGEX.nextNode()
 22541  
                 , root_1);
 22542  
 
 22543  6
                 // com\\googlecode\\sparkleg\\Sparql.g:629:76: ( expression )*
 22544  552
                 while ( stream_expression.hasNext() ) {
 22545  384
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22546  
 
 22547  
                 }
 22548  168
                 stream_expression.reset();
 22549  
 
 22550  168
                 adaptor.addChild(root_0, root_1);
 22551  
                 }
 22552  6
 
 22553  6
             }
 22554  
 
 22555  
 
 22556  174
             retval.tree = root_0;
 22557  
 
 22558  6
             }
 22559  6
 
 22560  174
             retval.stop = input.LT(-1);
 22561  6
 
 22562  6
 
 22563  174
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22564  174
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22565  
 
 22566  6
         }
 22567  0
         catch (RecognitionException re) {
 22568  6
             reportError(re);
 22569  0
             recover(input,re);
 22570  6
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22571  
 
 22572  
         }
 22573  6
 
 22574  6
         finally {
 22575  6
                 // do for sure before leaving
 22576  174
         }
 22577  174
         return retval;
 22578  6
     }
 22579  6
     // $ANTLR end "regexExpression"
 22580  6
 
 22581  6
 
 22582  16
     public static class subStringExpression_return extends ParserRuleReturnScope {
 22583  6
         Object tree;
 22584  16
         public Object getTree() { return tree; }
 22585  
     };
 22586  
 
 22587  
 
 22588  6
     // $ANTLR start "subStringExpression"
 22589  6
     // com\\googlecode\\sparkleg\\Sparql.g:632:1: subStringExpression : SUBSTR '(' expression ',' expression ( ',' expression )? ')' -> ^( SUBSTR ( expression )* ) ;
 22590  
     public final SparqlParser.subStringExpression_return subStringExpression() throws RecognitionException {
 22591  16
         SparqlParser.subStringExpression_return retval = new SparqlParser.subStringExpression_return();
 22592  22
         retval.start = input.LT(1);
 22593  6
 
 22594  
 
 22595  16
         Object root_0 = null;
 22596  6
 
 22597  22
         Token SUBSTR603=null;
 22598  16
         Token char_literal604=null;
 22599  22
         Token char_literal606=null;
 22600  16
         Token char_literal608=null;
 22601  22
         Token char_literal610=null;
 22602  16
         SparqlParser.expression_return expression605 =null;
 22603  6
 
 22604  22
         SparqlParser.expression_return expression607 =null;
 22605  
 
 22606  16
         SparqlParser.expression_return expression609 =null;
 22607  6
 
 22608  6
 
 22609  16
         Object SUBSTR603_tree=null;
 22610  22
         Object char_literal604_tree=null;
 22611  16
         Object char_literal606_tree=null;
 22612  22
         Object char_literal608_tree=null;
 22613  16
         Object char_literal610_tree=null;
 22614  22
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 22615  22
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 22616  16
         RewriteRuleTokenStream stream_SUBSTR=new RewriteRuleTokenStream(adaptor,"token SUBSTR");
 22617  16
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 22618  22
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22619  6
         try {
 22620  
             // com\\googlecode\\sparkleg\\Sparql.g:633:5: ( SUBSTR '(' expression ',' expression ( ',' expression )? ')' -> ^( SUBSTR ( expression )* ) )
 22621  6
             // com\\googlecode\\sparkleg\\Sparql.g:633:7: SUBSTR '(' expression ',' expression ( ',' expression )? ')'
 22622  
             {
 22623  22
             SUBSTR603=(Token)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression6492);  
 22624  16
             stream_SUBSTR.add(SUBSTR603);
 22625  
 
 22626  6
 
 22627  22
             char_literal604=(Token)match(input,209,FOLLOW_209_in_subStringExpression6494);  
 22628  16
             stream_209.add(char_literal604);
 22629  
 
 22630  
 
 22631  16
             pushFollow(FOLLOW_expression_in_subStringExpression6496);
 22632  16
             expression605=expression();
 22633  
 
 22634  16
             state._fsp--;
 22635  6
 
 22636  16
             stream_expression.add(expression605.getTree());
 22637  
 
 22638  16
             char_literal606=(Token)match(input,211,FOLLOW_211_in_subStringExpression6498);  
 22639  16
             stream_211.add(char_literal606);
 22640  
 
 22641  
 
 22642  16
             pushFollow(FOLLOW_expression_in_subStringExpression6500);
 22643  16
             expression607=expression();
 22644  
 
 22645  16
             state._fsp--;
 22646  
 
 22647  16
             stream_expression.add(expression607.getTree());
 22648  
 
 22649  
             // com\\googlecode\\sparkleg\\Sparql.g:633:44: ( ',' expression )?
 22650  16
             int alt126=2;
 22651  16
             switch ( input.LA(1) ) {
 22652  
                 case 211:
 22653  
                     {
 22654  8
                     alt126=1;
 22655  
                     }
 22656  6
                     break;
 22657  6
             }
 22658  
 
 22659  16
             switch (alt126) {
 22660  
                 case 1 :
 22661  
                     // com\\googlecode\\sparkleg\\Sparql.g:633:45: ',' expression
 22662  
                     {
 22663  8
                     char_literal608=(Token)match(input,211,FOLLOW_211_in_subStringExpression6503);  
 22664  8
                     stream_211.add(char_literal608);
 22665  
 
 22666  
 
 22667  14
                     pushFollow(FOLLOW_expression_in_subStringExpression6505);
 22668  14
                     expression609=expression();
 22669  
 
 22670  14
                     state._fsp--;
 22671  
 
 22672  8
                     stream_expression.add(expression609.getTree());
 22673  
 
 22674  
                     }
 22675  6
                     break;
 22676  6
 
 22677  
             }
 22678  
 
 22679  
 
 22680  16
             char_literal610=(Token)match(input,210,FOLLOW_210_in_subStringExpression6509);  
 22681  40
             stream_210.add(char_literal610);
 22682  18
 
 22683  
 
 22684  
             // AST REWRITE
 22685  6
             // elements: SUBSTR, expression
 22686  
             // token labels: 
 22687  6
             // rule labels: retval
 22688  
             // token list labels: 
 22689  
             // rule list labels: 
 22690  
             // wildcard labels: 
 22691  16
             retval.tree = root_0;
 22692  16
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22693  6
 
 22694  16
             root_0 = (Object)adaptor.nil();
 22695  
             // 633:66: -> ^( SUBSTR ( expression )* )
 22696  
             {
 22697  6
                 // com\\googlecode\\sparkleg\\Sparql.g:633:69: ^( SUBSTR ( expression )* )
 22698  
                 {
 22699  16
                 Object root_1 = (Object)adaptor.nil();
 22700  22
                 root_1 = (Object)adaptor.becomeRoot(
 22701  6
                 stream_SUBSTR.nextNode()
 22702  
                 , root_1);
 22703  
 
 22704  
                 // com\\googlecode\\sparkleg\\Sparql.g:633:78: ( expression )*
 22705  56
                 while ( stream_expression.hasNext() ) {
 22706  40
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22707  
 
 22708  
                 }
 22709  16
                 stream_expression.reset();
 22710  
 
 22711  16
                 adaptor.addChild(root_0, root_1);
 22712  
                 }
 22713  6
 
 22714  6
             }
 22715  
 
 22716  
 
 22717  16
             retval.tree = root_0;
 22718  
 
 22719  20
             }
 22720  
 
 22721  16
             retval.stop = input.LT(-1);
 22722  
 
 22723  
 
 22724  16
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22725  16
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22726  
 
 22727  
         }
 22728  20
         catch (RecognitionException re) {
 22729  20
             reportError(re);
 22730  0
             recover(input,re);
 22731  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22732  20
 
 22733  
         }
 22734  20
 
 22735  20
         finally {
 22736  
                 // do for sure before leaving
 22737  16
         }
 22738  36
         return retval;
 22739  20
     }
 22740  20
     // $ANTLR end "subStringExpression"
 22741  
 
 22742  
 
 22743  24
     public static class strReplaceExpression_return extends ParserRuleReturnScope {
 22744  
         Object tree;
 22745  20
         public Object getTree() { return tree; }
 22746  20
     };
 22747  
 
 22748  
 
 22749  20
     // $ANTLR start "strReplaceExpression"
 22750  20
     // com\\googlecode\\sparkleg\\Sparql.g:636:1: strReplaceExpression : REPLACE '(' expression ',' expression ',' expression ( ',' expression )? ')' -> ^( REPLACE ( expression )* ) ;
 22751  
     public final SparqlParser.strReplaceExpression_return strReplaceExpression() throws RecognitionException {
 22752  44
         SparqlParser.strReplaceExpression_return retval = new SparqlParser.strReplaceExpression_return();
 22753  24
         retval.start = input.LT(1);
 22754  20
 
 22755  
 
 22756  24
         Object root_0 = null;
 22757  
 
 22758  24
         Token REPLACE611=null;
 22759  24
         Token char_literal612=null;
 22760  24
         Token char_literal614=null;
 22761  24
         Token char_literal616=null;
 22762  24
         Token char_literal618=null;
 22763  44
         Token char_literal620=null;
 22764  44
         SparqlParser.expression_return expression613 =null;
 22765  
 
 22766  44
         SparqlParser.expression_return expression615 =null;
 22767  
 
 22768  24
         SparqlParser.expression_return expression617 =null;
 22769  
 
 22770  24
         SparqlParser.expression_return expression619 =null;
 22771  20
 
 22772  20
 
 22773  24
         Object REPLACE611_tree=null;
 22774  24
         Object char_literal612_tree=null;
 22775  24
         Object char_literal614_tree=null;
 22776  44
         Object char_literal616_tree=null;
 22777  24
         Object char_literal618_tree=null;
 22778  44
         Object char_literal620_tree=null;
 22779  24
         RewriteRuleTokenStream stream_211=new RewriteRuleTokenStream(adaptor,"token 211");
 22780  24
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 22781  24
         RewriteRuleTokenStream stream_REPLACE=new RewriteRuleTokenStream(adaptor,"token REPLACE");
 22782  24
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 22783  24
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22784  20
         try {
 22785  
             // com\\googlecode\\sparkleg\\Sparql.g:637:5: ( REPLACE '(' expression ',' expression ',' expression ( ',' expression )? ')' -> ^( REPLACE ( expression )* ) )
 22786  
             // com\\googlecode\\sparkleg\\Sparql.g:637:7: REPLACE '(' expression ',' expression ',' expression ( ',' expression )? ')'
 22787  
             {
 22788  44
             REPLACE611=(Token)match(input,REPLACE,FOLLOW_REPLACE_in_strReplaceExpression6543);  
 22789  24
             stream_REPLACE.add(REPLACE611);
 22790  
 
 22791  20
 
 22792  44
             char_literal612=(Token)match(input,209,FOLLOW_209_in_strReplaceExpression6545);  
 22793  24
             stream_209.add(char_literal612);
 22794  
 
 22795  
 
 22796  24
             pushFollow(FOLLOW_expression_in_strReplaceExpression6547);
 22797  24
             expression613=expression();
 22798  
 
 22799  24
             state._fsp--;
 22800  
 
 22801  24
             stream_expression.add(expression613.getTree());
 22802  
 
 22803  24
             char_literal614=(Token)match(input,211,FOLLOW_211_in_strReplaceExpression6549);  
 22804  44
             stream_211.add(char_literal614);
 22805  20
 
 22806  
 
 22807  24
             pushFollow(FOLLOW_expression_in_strReplaceExpression6551);
 22808  24
             expression615=expression();
 22809  
 
 22810  24
             state._fsp--;
 22811  
 
 22812  24
             stream_expression.add(expression615.getTree());
 22813  
 
 22814  24
             char_literal616=(Token)match(input,211,FOLLOW_211_in_strReplaceExpression6553);  
 22815  24
             stream_211.add(char_literal616);
 22816  
 
 22817  
 
 22818  24
             pushFollow(FOLLOW_expression_in_strReplaceExpression6555);
 22819  70
             expression617=expression();
 22820  46
 
 22821  24
             state._fsp--;
 22822  
 
 22823  70
             stream_expression.add(expression617.getTree());
 22824  
 
 22825  46
             // com\\googlecode\\sparkleg\\Sparql.g:637:60: ( ',' expression )?
 22826  70
             int alt127=2;
 22827  70
             switch ( input.LA(1) ) {
 22828  
                 case 211:
 22829  
                     {
 22830  46
                     alt127=1;
 22831  46
                     }
 22832  46
                     break;
 22833  46
             }
 22834  46
 
 22835  24
             switch (alt127) {
 22836  
                 case 1 :
 22837  
                     // com\\googlecode\\sparkleg\\Sparql.g:637:61: ',' expression
 22838  
                     {
 22839  46
                     char_literal618=(Token)match(input,211,FOLLOW_211_in_strReplaceExpression6558);  
 22840  46
                     stream_211.add(char_literal618);
 22841  
 
 22842  
 
 22843  46
                     pushFollow(FOLLOW_expression_in_strReplaceExpression6560);
 22844  46
                     expression619=expression();
 22845  
 
 22846  0
                     state._fsp--;
 22847  46
 
 22848  46
                     stream_expression.add(expression619.getTree());
 22849  
 
 22850  46
                     }
 22851  
                     break;
 22852  46
 
 22853  
             }
 22854  
 
 22855  
 
 22856  24
             char_literal620=(Token)match(input,210,FOLLOW_210_in_strReplaceExpression6564);  
 22857  24
             stream_210.add(char_literal620);
 22858  
 
 22859  
 
 22860  
             // AST REWRITE
 22861  46
             // elements: expression, REPLACE
 22862  46
             // token labels: 
 22863  
             // rule labels: retval
 22864  46
             // token list labels: 
 22865  
             // rule list labels: 
 22866  
             // wildcard labels: 
 22867  24
             retval.tree = root_0;
 22868  24
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22869  46
 
 22870  70
             root_0 = (Object)adaptor.nil();
 22871  
             // 637:82: -> ^( REPLACE ( expression )* )
 22872  
             {
 22873  
                 // com\\googlecode\\sparkleg\\Sparql.g:637:85: ^( REPLACE ( expression )* )
 22874  46
                 {
 22875  24
                 Object root_1 = (Object)adaptor.nil();
 22876  70
                 root_1 = (Object)adaptor.becomeRoot(
 22877  
                 stream_REPLACE.nextNode()
 22878  
                 , root_1);
 22879  
 
 22880  
                 // com\\googlecode\\sparkleg\\Sparql.g:637:95: ( expression )*
 22881  96
                 while ( stream_expression.hasNext() ) {
 22882  118
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22883  
 
 22884  
                 }
 22885  24
                 stream_expression.reset();
 22886  46
 
 22887  24
                 adaptor.addChild(root_0, root_1);
 22888  
                 }
 22889  46
 
 22890  46
             }
 22891  
 
 22892  
 
 22893  24
             retval.tree = root_0;
 22894  
 
 22895  
             }
 22896  
 
 22897  24
             retval.stop = input.LT(-1);
 22898  
 
 22899  
 
 22900  24
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22901  24
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22902  46
 
 22903  46
         }
 22904  0
         catch (RecognitionException re) {
 22905  0
             reportError(re);
 22906  0
             recover(input,re);
 22907  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22908  106
 
 22909  
         }
 22910  106
 
 22911  0
         finally {
 22912  
                 // do for sure before leaving
 22913  24
         }
 22914  24
         return retval;
 22915  
     }
 22916  
     // $ANTLR end "strReplaceExpression"
 22917  106
 
 22918  106
 
 22919  80
     public static class existsFunction_return extends ParserRuleReturnScope {
 22920  
         Object tree;
 22921  106
         public Object getTree() { return tree; }
 22922  
     };
 22923  106
 
 22924  106
 
 22925  106
     // $ANTLR start "existsFunction"
 22926  106
     // com\\googlecode\\sparkleg\\Sparql.g:640:1: existsFunction : EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) ;
 22927  106
     public final SparqlParser.existsFunction_return existsFunction() throws RecognitionException {
 22928  186
         SparqlParser.existsFunction_return retval = new SparqlParser.existsFunction_return();
 22929  186
         retval.start = input.LT(1);
 22930  106
 
 22931  106
 
 22932  186
         Object root_0 = null;
 22933  106
 
 22934  186
         Token EXISTS621=null;
 22935  186
         SparqlParser.groupGraphPattern_return groupGraphPattern622 =null;
 22936  106
 
 22937  106
 
 22938  186
         Object EXISTS621_tree=null;
 22939  186
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22940  186
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22941  106
         try {
 22942  106
             // com\\googlecode\\sparkleg\\Sparql.g:641:5: ( EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) )
 22943  106
             // com\\googlecode\\sparkleg\\Sparql.g:641:7: EXISTS groupGraphPattern
 22944  106
             {
 22945  186
             EXISTS621=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction6590);  
 22946  186
             stream_EXISTS.add(EXISTS621);
 22947  106
 
 22948  106
 
 22949  186
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction6592);
 22950  186
             groupGraphPattern622=groupGraphPattern();
 22951  106
 
 22952  186
             state._fsp--;
 22953  106
 
 22954  186
             stream_groupGraphPattern.add(groupGraphPattern622.getTree());
 22955  106
 
 22956  
             // AST REWRITE
 22957  106
             // elements: EXISTS, groupGraphPattern
 22958  
             // token labels: 
 22959  106
             // rule labels: retval
 22960  
             // token list labels: 
 22961  106
             // rule list labels: 
 22962  
             // wildcard labels: 
 22963  186
             retval.tree = root_0;
 22964  80
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22965  106
 
 22966  80
             root_0 = (Object)adaptor.nil();
 22967  106
             // 641:32: -> ^( EXISTS groupGraphPattern )
 22968  
             {
 22969  106
                 // com\\googlecode\\sparkleg\\Sparql.g:641:35: ^( EXISTS groupGraphPattern )
 22970  
                 {
 22971  80
                 Object root_1 = (Object)adaptor.nil();
 22972  186
                 root_1 = (Object)adaptor.becomeRoot(
 22973  106
                 stream_EXISTS.nextNode()
 22974  106
                 , root_1);
 22975  106
 
 22976  186
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22977  106
 
 22978  186
                 adaptor.addChild(root_0, root_1);
 22979  106
                 }
 22980  106
 
 22981  106
             }
 22982  106
 
 22983  106
 
 22984  186
             retval.tree = root_0;
 22985  106
 
 22986  106
             }
 22987  106
 
 22988  186
             retval.stop = input.LT(-1);
 22989  106
 
 22990  106
 
 22991  186
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22992  186
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22993  106
 
 22994  106
         }
 22995  106
         catch (RecognitionException re) {
 22996  106
             reportError(re);
 22997  106
             recover(input,re);
 22998  106
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22999  106
 
 23000  106
         }
 23001  106
 
 23002  106
         finally {
 23003  106
                 // do for sure before leaving
 23004  186
         }
 23005  186
         return retval;
 23006  106
     }
 23007  106
     // $ANTLR end "existsFunction"
 23008  106
 
 23009  106
 
 23010  106
     public static class notExistsFunction_return extends ParserRuleReturnScope {
 23011  106
         Object tree;
 23012  106
         public Object getTree() { return tree; }
 23013  106
     };
 23014  106
 
 23015  106
 
 23016  106
     // $ANTLR start "notExistsFunction"
 23017  106
     // com\\googlecode\\sparkleg\\Sparql.g:644:1: notExistsFunction : NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) ;
 23018  106
     public final SparqlParser.notExistsFunction_return notExistsFunction() throws RecognitionException {
 23019  290
         SparqlParser.notExistsFunction_return retval = new SparqlParser.notExistsFunction_return();
 23020  184
         retval.start = input.LT(1);
 23021  
 
 23022  106
 
 23023  290
         Object root_0 = null;
 23024  
 
 23025  184
         Token NOT623=null;
 23026  218
         Token EXISTS624=null;
 23027  184
         SparqlParser.groupGraphPattern_return groupGraphPattern625 =null;
 23028  34
 
 23029  
 
 23030  184
         Object NOT623_tree=null;
 23031  196
         Object EXISTS624_tree=null;
 23032  184
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 23033  196
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 23034  184
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 23035  
         try {
 23036  14
             // com\\googlecode\\sparkleg\\Sparql.g:645:5: ( NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) )
 23037  
             // com\\googlecode\\sparkleg\\Sparql.g:645:7: NOT EXISTS groupGraphPattern
 23038  14
             {
 23039  184
             NOT623=(Token)match(input,NOT,FOLLOW_NOT_in_notExistsFunction6617);  
 23040  184
             stream_NOT.add(NOT623);
 23041  10
 
 23042  
 
 23043  194
             EXISTS624=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_notExistsFunction6619);  
 23044  184
             stream_EXISTS.add(EXISTS624);
 23045  
 
 23046  24
 
 23047  184
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction6621);
 23048  208
             groupGraphPattern625=groupGraphPattern();
 23049  
 
 23050  184
             state._fsp--;
 23051  6
 
 23052  184
             stream_groupGraphPattern.add(groupGraphPattern625.getTree());
 23053  6
 
 23054  
             // AST REWRITE
 23055  
             // elements: groupGraphPattern
 23056  6
             // token labels: 
 23057  
             // rule labels: retval
 23058  6
             // token list labels: 
 23059  
             // rule list labels: 
 23060  
             // wildcard labels: 
 23061  184
             retval.tree = root_0;
 23062  184
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23063  
 
 23064  184
             root_0 = (Object)adaptor.nil();
 23065  
             // 645:36: -> ^( NOT_EXISTS groupGraphPattern )
 23066  
             {
 23067  106
                 // com\\googlecode\\sparkleg\\Sparql.g:645:39: ^( NOT_EXISTS groupGraphPattern )
 23068  
                 {
 23069  184
                 Object root_1 = (Object)adaptor.nil();
 23070  184
                 root_1 = (Object)adaptor.becomeRoot(
 23071  34
                 (Object)adaptor.create(NOT_EXISTS, "NOT_EXISTS")
 23072  34
                 , root_1);
 23073  
 
 23074  184
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 23075  34
 
 23076  218
                 adaptor.addChild(root_0, root_1);
 23077  
                 }
 23078  
 
 23079  
             }
 23080  34
 
 23081  34
 
 23082  184
             retval.tree = root_0;
 23083  
 
 23084  
             }
 23085  
 
 23086  184
             retval.stop = input.LT(-1);
 23087  
 
 23088  
 
 23089  218
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23090  184
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23091  
 
 23092  
         }
 23093  0
         catch (RecognitionException re) {
 23094  0
             reportError(re);
 23095  0
             recover(input,re);
 23096  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23097  
 
 23098  
         }
 23099  
 
 23100  0
         finally {
 23101  
                 // do for sure before leaving
 23102  184
         }
 23103  184
         return retval;
 23104  34
     }
 23105  34
     // $ANTLR end "notExistsFunction"
 23106  
 
 23107  
 
 23108  14
     public static class aggregate_return extends ParserRuleReturnScope {
 23109  
         Object tree;
 23110  14
         public Object getTree() { return tree; }
 23111  
     };
 23112  
 
 23113  
 
 23114  
     // $ANTLR start "aggregate"
 23115  
     // com\\googlecode\\sparkleg\\Sparql.g:648:1: aggregate : ( COUNT '(' ( DISTINCT )? ( '*' | expression ) ')' -> ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* ) | SUM '(' ( DISTINCT )? expression ')' -> ^( SUM ( DISTINCT )* expression ) | MIN '(' ( DISTINCT )? expression ')' -> ^( MIN ( DISTINCT )* expression ) | MAX '(' ( DISTINCT )? expression ')' -> ^( MAX ( DISTINCT )* expression ) | AVG '(' ( DISTINCT )? expression ')' -> ^( AVG ( DISTINCT )* expression ) | SAMPLE '(' ( DISTINCT )? expression ')' -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT '(' ( DISTINCT )? expression ( ';' SEPARATOR '=' string )? ')' -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) );
 23116  
     public final SparqlParser.aggregate_return aggregate() throws RecognitionException {
 23117  424
         SparqlParser.aggregate_return retval = new SparqlParser.aggregate_return();
 23118  424
         retval.start = input.LT(1);
 23119  
 
 23120  
 
 23121  424
         Object root_0 = null;
 23122  
 
 23123  424
         Token COUNT626=null;
 23124  424
         Token char_literal627=null;
 23125  424
         Token DISTINCT628=null;
 23126  424
         Token char_literal629=null;
 23127  424
         Token char_literal631=null;
 23128  424
         Token SUM632=null;
 23129  424
         Token char_literal633=null;
 23130  424
         Token DISTINCT634=null;
 23131  424
         Token char_literal636=null;
 23132  424
         Token MIN637=null;
 23133  424
         Token char_literal638=null;
 23134  424
         Token DISTINCT639=null;
 23135  424
         Token char_literal641=null;
 23136  424
         Token MAX642=null;
 23137  424
         Token char_literal643=null;
 23138  424
         Token DISTINCT644=null;
 23139  424
         Token char_literal646=null;
 23140  424
         Token AVG647=null;
 23141  424
         Token char_literal648=null;
 23142  424
         Token DISTINCT649=null;
 23143  424
         Token char_literal651=null;
 23144  424
         Token SAMPLE652=null;
 23145  424
         Token char_literal653=null;
 23146  424
         Token DISTINCT654=null;
 23147  424
         Token char_literal656=null;
 23148  424
         Token GROUP_CONCAT657=null;
 23149  424
         Token char_literal658=null;
 23150  424
         Token DISTINCT659=null;
 23151  424
         Token char_literal661=null;
 23152  424
         Token SEPARATOR662=null;
 23153  424
         Token char_literal663=null;
 23154  424
         Token char_literal665=null;
 23155  424
         SparqlParser.expression_return expression630 =null;
 23156  
 
 23157  424
         SparqlParser.expression_return expression635 =null;
 23158  
 
 23159  424
         SparqlParser.expression_return expression640 =null;
 23160  
 
 23161  424
         SparqlParser.expression_return expression645 =null;
 23162  
 
 23163  424
         SparqlParser.expression_return expression650 =null;
 23164  
 
 23165  424
         SparqlParser.expression_return expression655 =null;
 23166  
 
 23167  424
         SparqlParser.expression_return expression660 =null;
 23168  
 
 23169  424
         SparqlParser.string_return string664 =null;
 23170  
 
 23171  
 
 23172  424
         Object COUNT626_tree=null;
 23173  424
         Object char_literal627_tree=null;
 23174  424
         Object DISTINCT628_tree=null;
 23175  424
         Object char_literal629_tree=null;
 23176  424
         Object char_literal631_tree=null;
 23177  424
         Object SUM632_tree=null;
 23178  424
         Object char_literal633_tree=null;
 23179  424
         Object DISTINCT634_tree=null;
 23180  424
         Object char_literal636_tree=null;
 23181  424
         Object MIN637_tree=null;
 23182  424
         Object char_literal638_tree=null;
 23183  424
         Object DISTINCT639_tree=null;
 23184  424
         Object char_literal641_tree=null;
 23185  424
         Object MAX642_tree=null;
 23186  424
         Object char_literal643_tree=null;
 23187  424
         Object DISTINCT644_tree=null;
 23188  424
         Object char_literal646_tree=null;
 23189  424
         Object AVG647_tree=null;
 23190  424
         Object char_literal648_tree=null;
 23191  424
         Object DISTINCT649_tree=null;
 23192  424
         Object char_literal651_tree=null;
 23193  424
         Object SAMPLE652_tree=null;
 23194  424
         Object char_literal653_tree=null;
 23195  444
         Object DISTINCT654_tree=null;
 23196  424
         Object char_literal656_tree=null;
 23197  444
         Object GROUP_CONCAT657_tree=null;
 23198  424
         Object char_literal658_tree=null;
 23199  424
         Object DISTINCT659_tree=null;
 23200  424
         Object char_literal661_tree=null;
 23201  424
         Object SEPARATOR662_tree=null;
 23202  424
         Object char_literal663_tree=null;
 23203  424
         Object char_literal665_tree=null;
 23204  424
         RewriteRuleTokenStream stream_212=new RewriteRuleTokenStream(adaptor,"token 212");
 23205  424
         RewriteRuleTokenStream stream_SAMPLE=new RewriteRuleTokenStream(adaptor,"token SAMPLE");
 23206  458
         RewriteRuleTokenStream stream_210=new RewriteRuleTokenStream(adaptor,"token 210");
 23207  424
         RewriteRuleTokenStream stream_AVG=new RewriteRuleTokenStream(adaptor,"token AVG");
 23208  424
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 23209  424
         RewriteRuleTokenStream stream_GROUP_CONCAT=new RewriteRuleTokenStream(adaptor,"token GROUP_CONCAT");
 23210  438
         RewriteRuleTokenStream stream_209=new RewriteRuleTokenStream(adaptor,"token 209");
 23211  438
         RewriteRuleTokenStream stream_MAX=new RewriteRuleTokenStream(adaptor,"token MAX");
 23212  424
         RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
 23213  424
         RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
 23214  424
         RewriteRuleTokenStream stream_MIN=new RewriteRuleTokenStream(adaptor,"token MIN");
 23215  438
         RewriteRuleTokenStream stream_SUM=new RewriteRuleTokenStream(adaptor,"token SUM");
 23216  424
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 23217  424
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 23218  424
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 23219  444
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 23220  20
         try {
 23221  
             // com\\googlecode\\sparkleg\\Sparql.g:649:5: ( COUNT '(' ( DISTINCT )? ( '*' | expression ) ')' -> ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* ) | SUM '(' ( DISTINCT )? expression ')' -> ^( SUM ( DISTINCT )* expression ) | MIN '(' ( DISTINCT )? expression ')' -> ^( MIN ( DISTINCT )* expression ) | MAX '(' ( DISTINCT )? expression ')' -> ^( MAX ( DISTINCT )* expression ) | AVG '(' ( DISTINCT )? expression ')' -> ^( AVG ( DISTINCT )* expression ) | SAMPLE '(' ( DISTINCT )? expression ')' -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT '(' ( DISTINCT )? expression ( ';' SEPARATOR '=' string )? ')' -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) )
 23222  444
             int alt137=7;
 23223  424
             switch ( input.LA(1) ) {
 23224  20
             case COUNT:
 23225  
                 {
 23226  136
                 alt137=1;
 23227  
                 }
 23228  136
                 break;
 23229  
             case SUM:
 23230  
                 {
 23231  48
                 alt137=2;
 23232  34
                 }
 23233  82
                 break;
 23234  
             case MIN:
 23235  
                 {
 23236  56
                 alt137=3;
 23237  
                 }
 23238  56
                 break;
 23239  
             case MAX:
 23240  
                 {
 23241  40
                 alt137=4;
 23242  
                 }
 23243  74
                 break;
 23244  34
             case AVG:
 23245  
                 {
 23246  130
                 alt137=5;
 23247  
                 }
 23248  96
                 break;
 23249  
             case SAMPLE:
 23250  
                 {
 23251  58
                 alt137=6;
 23252  34
                 }
 23253  24
                 break;
 23254  
             case GROUP_CONCAT:
 23255  
                 {
 23256  24
                 alt137=7;
 23257  34
                 }
 23258  24
                 break;
 23259  
             default:
 23260  0
                 NoViableAltException nvae =
 23261  
                     new NoViableAltException("", 137, 0, input);
 23262  
 
 23263  34
                 throw nvae;
 23264  
 
 23265  
             }
 23266  48
 
 23267  438
             switch (alt137) {
 23268  
                 case 1 :
 23269  
                     // com\\googlecode\\sparkleg\\Sparql.g:649:7: COUNT '(' ( DISTINCT )? ( '*' | expression ) ')'
 23270  
                     {
 23271  136
                     COUNT626=(Token)match(input,COUNT,FOLLOW_COUNT_in_aggregate6646);  
 23272  170
                     stream_COUNT.add(COUNT626);
 23273  
 
 23274  
 
 23275  190
                     char_literal627=(Token)match(input,209,FOLLOW_209_in_aggregate6648);  
 23276  156
                     stream_209.add(char_literal627);
 23277  
 
 23278  
 
 23279  34
                     // com\\googlecode\\sparkleg\\Sparql.g:649:17: ( DISTINCT )?
 23280  136
                     int alt128=2;
 23281  170
                     switch ( input.LA(1) ) {
 23282  
                         case DISTINCT:
 23283  
                             {
 23284  0
                             alt128=1;
 23285  
                             }
 23286  
                             break;
 23287  34
                     }
 23288  
 
 23289  136
                     switch (alt128) {
 23290  34
                         case 1 :
 23291  
                             // com\\googlecode\\sparkleg\\Sparql.g:649:17: DISTINCT
 23292  
                             {
 23293  0
                             DISTINCT628=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6650);  
 23294  12
                             stream_DISTINCT.add(DISTINCT628);
 23295  12
 
 23296  
 
 23297  
                             }
 23298  12
                             break;
 23299  12
 
 23300  
                     }
 23301  
 
 23302  
 
 23303  12
                     // com\\googlecode\\sparkleg\\Sparql.g:649:27: ( '*' | expression )
 23304  148
                     int alt129=2;
 23305  136
                     switch ( input.LA(1) ) {
 23306  
                     case ASTERISK:
 23307  
                         {
 23308  56
                         alt129=1;
 23309  
                         }
 23310  56
                         break;
 23311  
                     case ABS:
 23312  12
                     case AVG:
 23313  
                     case BNODE:
 23314  
                     case BOUND:
 23315  
                     case CEIL:
 23316  
                     case COALESCE:
 23317  
                     case CONCAT:
 23318  
                     case CONTAINS:
 23319  
                     case COUNT:
 23320  
                     case DATATYPE:
 23321  
                     case DAY:
 23322  
                     case DECIMAL:
 23323  
                     case DECIMAL_NEGATIVE:
 23324  
                     case DECIMAL_POSITIVE:
 23325  
                     case DOUBLE:
 23326  12
                     case DOUBLE_NEGATIVE:
 23327  12
                     case DOUBLE_POSITIVE:
 23328  
                     case ENCODE_FOR_URI:
 23329  12
                     case EXISTS:
 23330  
                     case FALSE:
 23331  12
                     case FLOOR:
 23332  
                     case GROUP_CONCAT:
 23333  12
                     case HOURS:
 23334  12
                     case IF:
 23335  
                     case INTEGER:
 23336  
                     case INTEGER_NEGATIVE:
 23337  
                     case INTEGER_POSITIVE:
 23338  
                     case IRI:
 23339  
                     case IRI_REF:
 23340  
                     case ISBLANK:
 23341  
                     case ISIRI:
 23342  
                     case ISLITERAL:
 23343  
                     case ISNUMERIC:
 23344  12
                     case ISURI:
 23345  12
                     case LANG:
 23346  
                     case LANGMATCHES:
 23347  12
                     case LCASE:
 23348  
                     case MAX:
 23349  
                     case MD5:
 23350  
                     case MIN:
 23351  
                     case MINUS:
 23352  12
                     case MINUTES:
 23353  12
                     case MONTH:
 23354  
                     case NEGATION:
 23355  
                     case NOT:
 23356  
                     case NOW:
 23357  
                     case PLUS:
 23358  12
                     case PNAME_LN:
 23359  
                     case PNAME_NS:
 23360  
                     case RAND:
 23361  
                     case REGEX:
 23362  
                     case REPLACE:
 23363  
                     case ROUND:
 23364  12
                     case SAMETERM:
 23365  
                     case SAMPLE:
 23366  12
                     case SECONDS:
 23367  
                     case SHA1:
 23368  12
                     case SHA256:
 23369  
                     case SHA384:
 23370  
                     case SHA512:
 23371  
                     case STR:
 23372  
                     case STRAFTER:
 23373  
                     case STRBEFORE:
 23374  12
                     case STRDT:
 23375  
                     case STRENDS:
 23376  
                     case STRING_LITERAL1:
 23377  12
                     case STRING_LITERAL2:
 23378  
                     case STRING_LITERAL_LONG1:
 23379  
                     case STRING_LITERAL_LONG2:
 23380  
                     case STRLANG:
 23381  14
                     case STRLEN:
 23382  14
                     case STRSTARTS:
 23383  
                     case SUBSTR:
 23384  
                     case SUM:
 23385  14
                     case TIMEZONE:
 23386  14
                     case TRUE:
 23387  
                     case TZ:
 23388  
                     case UCASE:
 23389  
                     case URI:
 23390  14
                     case VAR1:
 23391  14
                     case VAR2:
 23392  
                     case YEAR:
 23393  
                     case 209:
 23394  
                         {
 23395  80
                         alt129=2;
 23396  
                         }
 23397  80
                         break;
 23398  
                     default:
 23399  14
                         NoViableAltException nvae =
 23400  
                             new NoViableAltException("", 129, 0, input);
 23401  
 
 23402  0
                         throw nvae;
 23403  
 
 23404  
                     }
 23405  
 
 23406  136
                     switch (alt129) {
 23407  
                         case 1 :
 23408  
                             // com\\googlecode\\sparkleg\\Sparql.g:649:28: '*'
 23409  
                             {
 23410  56
                             char_literal629=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate6654);  
 23411  56
                             stream_ASTERISK.add(char_literal629);
 23412  
 
 23413  14
 
 23414  14
                             }
 23415  56
                             break;
 23416  14
                         case 2 :
 23417  
                             // com\\googlecode\\sparkleg\\Sparql.g:649:34: expression
 23418  14
                             {
 23419  80
                             pushFollow(FOLLOW_expression_in_aggregate6658);
 23420  94
                             expression630=expression();
 23421  14
 
 23422  80
                             state._fsp--;
 23423  
 
 23424  80
                             stream_expression.add(expression630.getTree());
 23425  
 
 23426  
                             }
 23427  
                             break;
 23428  
 
 23429  
                     }
 23430  
 
 23431  14
 
 23432  150
                     char_literal631=(Token)match(input,210,FOLLOW_210_in_aggregate6661);  
 23433  136
                     stream_210.add(char_literal631);
 23434  14
 
 23435  
 
 23436  
                     // AST REWRITE
 23437  
                     // elements: COUNT, ASTERISK, DISTINCT, expression
 23438  
                     // token labels: 
 23439  14
                     // rule labels: retval
 23440  14
                     // token list labels: 
 23441  
                     // rule list labels: 
 23442  
                     // wildcard labels: 
 23443  136
                     retval.tree = root_0;
 23444  136
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23445  14
 
 23446  136
                     root_0 = (Object)adaptor.nil();
 23447  
                     // 649:50: -> ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* )
 23448  
                     {
 23449  
                         // com\\googlecode\\sparkleg\\Sparql.g:649:53: ^( COUNT ( DISTINCT )* ( '*' )* ( expression )* )
 23450  
                         {
 23451  150
                         Object root_1 = (Object)adaptor.nil();
 23452  136
                         root_1 = (Object)adaptor.becomeRoot(
 23453  14
                         stream_COUNT.nextNode()
 23454  
                         , root_1);
 23455  14
 
 23456  
                         // com\\googlecode\\sparkleg\\Sparql.g:649:61: ( DISTINCT )*
 23457  136
                         while ( stream_DISTINCT.hasNext() ) {
 23458  0
                             adaptor.addChild(root_1, 
 23459  
                             stream_DISTINCT.nextNode()
 23460  
                             );
 23461  14
 
 23462  
                         }
 23463  136
                         stream_DISTINCT.reset();
 23464  14
 
 23465  
                         // com\\googlecode\\sparkleg\\Sparql.g:649:71: ( '*' )*
 23466  192
                         while ( stream_ASTERISK.hasNext() ) {
 23467  56
                             adaptor.addChild(root_1, 
 23468  10
                             stream_ASTERISK.nextNode()
 23469  10
                             );
 23470  
 
 23471  
                         }
 23472  146
                         stream_ASTERISK.reset();
 23473  10
 
 23474  
                         // com\\googlecode\\sparkleg\\Sparql.g:649:76: ( expression )*
 23475  216
                         while ( stream_expression.hasNext() ) {
 23476  80
                             adaptor.addChild(root_1, stream_expression.nextTree());
 23477  10
 
 23478  10
                         }
 23479  136
                         stream_expression.reset();
 23480  
 
 23481  136
                         adaptor.addChild(root_0, root_1);
 23482  
                         }
 23483  
 
 23484  
                     }
 23485  
 
 23486  10
 
 23487  136
                     retval.tree = root_0;
 23488  
 
 23489  
                     }
 23490  136
                     break;
 23491  
                 case 2 :
 23492  
                     // com\\googlecode\\sparkleg\\Sparql.g:650:7: SUM '(' ( DISTINCT )? expression ')'
 23493  
                     {
 23494  48
                     SUM632=(Token)match(input,SUM,FOLLOW_SUM_in_aggregate6684);  
 23495  48
                     stream_SUM.add(SUM632);
 23496  
 
 23497  
 
 23498  48
                     char_literal633=(Token)match(input,209,FOLLOW_209_in_aggregate6686);  
 23499  48
                     stream_209.add(char_literal633);
 23500  10
 
 23501  10
 
 23502  
                     // com\\googlecode\\sparkleg\\Sparql.g:650:15: ( DISTINCT )?
 23503  58
                     int alt130=2;
 23504  48
                     switch ( input.LA(1) ) {
 23505  10
                         case DISTINCT:
 23506  
                             {
 23507  10
                             alt130=1;
 23508  10
                             }
 23509  
                             break;
 23510  
                     }
 23511  
 
 23512  48
                     switch (alt130) {
 23513  
                         case 1 :
 23514  
                             // com\\googlecode\\sparkleg\\Sparql.g:650:15: DISTINCT
 23515  
                             {
 23516  0
                             DISTINCT634=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6688);  
 23517  0
                             stream_DISTINCT.add(DISTINCT634);
 23518  10
 
 23519  10
 
 23520  
                             }
 23521  10
                             break;
 23522  
 
 23523  
                     }
 23524  
 
 23525  
 
 23526  58
                     pushFollow(FOLLOW_expression_in_aggregate6691);
 23527  58
                     expression635=expression();
 23528  
 
 23529  48
                     state._fsp--;
 23530  
 
 23531  48
                     stream_expression.add(expression635.getTree());
 23532  10
 
 23533  48
                     char_literal636=(Token)match(input,210,FOLLOW_210_in_aggregate6693);  
 23534  48
                     stream_210.add(char_literal636);
 23535  
 
 23536  
 
 23537  
                     // AST REWRITE
 23538  10
                     // elements: SUM, expression, DISTINCT
 23539  
                     // token labels: 
 23540  10
                     // rule labels: retval
 23541  
                     // token list labels: 
 23542  10
                     // rule list labels: 
 23543  
                     // wildcard labels: 
 23544  48
                     retval.tree = root_0;
 23545  48
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23546  
 
 23547  48
                     root_0 = (Object)adaptor.nil();
 23548  10
                     // 650:40: -> ^( SUM ( DISTINCT )* expression )
 23549  
                     {
 23550  
                         // com\\googlecode\\sparkleg\\Sparql.g:650:43: ^( SUM ( DISTINCT )* expression )
 23551  10
                         {
 23552  48
                         Object root_1 = (Object)adaptor.nil();
 23553  48
                         root_1 = (Object)adaptor.becomeRoot(
 23554  
                         stream_SUM.nextNode()
 23555  24
                         , root_1);
 23556  24
 
 23557  
                         // com\\googlecode\\sparkleg\\Sparql.g:650:49: ( DISTINCT )*
 23558  48
                         while ( stream_DISTINCT.hasNext() ) {
 23559  24
                             adaptor.addChild(root_1, 
 23560  24
                             stream_DISTINCT.nextNode()
 23561  
                             );
 23562  
 
 23563  
                         }
 23564  72
                         stream_DISTINCT.reset();
 23565  24
 
 23566  48
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23567  
 
 23568  48
                         adaptor.addChild(root_0, root_1);
 23569  
                         }
 23570  
 
 23571  
                     }
 23572  
 
 23573  24
 
 23574  48
                     retval.tree = root_0;
 23575  
 
 23576  
                     }
 23577  48
                     break;
 23578  
                 case 3 :
 23579  
                     // com\\googlecode\\sparkleg\\Sparql.g:651:7: MIN '(' ( DISTINCT )? expression ')'
 23580  
                     {
 23581  56
                     MIN637=(Token)match(input,MIN,FOLLOW_MIN_in_aggregate6712);  
 23582  56
                     stream_MIN.add(MIN637);
 23583  
 
 23584  
 
 23585  56
                     char_literal638=(Token)match(input,209,FOLLOW_209_in_aggregate6714);  
 23586  56
                     stream_209.add(char_literal638);
 23587  24
 
 23588  24
 
 23589  
                     // com\\googlecode\\sparkleg\\Sparql.g:651:15: ( DISTINCT )?
 23590  80
                     int alt131=2;
 23591  56
                     switch ( input.LA(1) ) {
 23592  24
                         case DISTINCT:
 23593  
                             {
 23594  24
                             alt131=1;
 23595  24
                             }
 23596  
                             break;
 23597  
                     }
 23598  
 
 23599  56
                     switch (alt131) {
 23600  
                         case 1 :
 23601  
                             // com\\googlecode\\sparkleg\\Sparql.g:651:15: DISTINCT
 23602  
                             {
 23603  0
                             DISTINCT639=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6716);  
 23604  0
                             stream_DISTINCT.add(DISTINCT639);
 23605  24
 
 23606  24
 
 23607  
                             }
 23608  24
                             break;
 23609  
 
 23610  
                     }
 23611  
 
 23612  
 
 23613  80
                     pushFollow(FOLLOW_expression_in_aggregate6719);
 23614  80
                     expression640=expression();
 23615  
 
 23616  56
                     state._fsp--;
 23617  
 
 23618  56
                     stream_expression.add(expression640.getTree());
 23619  24
 
 23620  56
                     char_literal641=(Token)match(input,210,FOLLOW_210_in_aggregate6721);  
 23621  56
                     stream_210.add(char_literal641);
 23622  
 
 23623  
 
 23624  
                     // AST REWRITE
 23625  24
                     // elements: MIN, expression, DISTINCT
 23626  
                     // token labels: 
 23627  24
                     // rule labels: retval
 23628  
                     // token list labels: 
 23629  24
                     // rule list labels: 
 23630  
                     // wildcard labels: 
 23631  56
                     retval.tree = root_0;
 23632  56
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23633  
 
 23634  56
                     root_0 = (Object)adaptor.nil();
 23635  24
                     // 651:40: -> ^( MIN ( DISTINCT )* expression )
 23636  
                     {
 23637  
                         // com\\googlecode\\sparkleg\\Sparql.g:651:43: ^( MIN ( DISTINCT )* expression )
 23638  24
                         {
 23639  56
                         Object root_1 = (Object)adaptor.nil();
 23640  56
                         root_1 = (Object)adaptor.becomeRoot(
 23641  
                         stream_MIN.nextNode()
 23642  6
                         , root_1);
 23643  6
 
 23644  
                         // com\\googlecode\\sparkleg\\Sparql.g:651:49: ( DISTINCT )*
 23645  56
                         while ( stream_DISTINCT.hasNext() ) {
 23646  6
                             adaptor.addChild(root_1, 
 23647  6
                             stream_DISTINCT.nextNode()
 23648  
                             );
 23649  
 
 23650  
                         }
 23651  62
                         stream_DISTINCT.reset();
 23652  6
 
 23653  56
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23654  
 
 23655  56
                         adaptor.addChild(root_0, root_1);
 23656  
                         }
 23657  
 
 23658  
                     }
 23659  
 
 23660  6
 
 23661  56
                     retval.tree = root_0;
 23662  
 
 23663  
                     }
 23664  56
                     break;
 23665  
                 case 4 :
 23666  
                     // com\\googlecode\\sparkleg\\Sparql.g:652:7: MAX '(' ( DISTINCT )? expression ')'
 23667  
                     {
 23668  40
                     MAX642=(Token)match(input,MAX,FOLLOW_MAX_in_aggregate6740);  
 23669  40
                     stream_MAX.add(MAX642);
 23670  
 
 23671  
 
 23672  40
                     char_literal643=(Token)match(input,209,FOLLOW_209_in_aggregate6742);  
 23673  40
                     stream_209.add(char_literal643);
 23674  6
 
 23675  6
 
 23676  
                     // com\\googlecode\\sparkleg\\Sparql.g:652:15: ( DISTINCT )?
 23677  46
                     int alt132=2;
 23678  40
                     switch ( input.LA(1) ) {
 23679  6
                         case DISTINCT:
 23680  
                             {
 23681  6
                             alt132=1;
 23682  6
                             }
 23683  
                             break;
 23684  
                     }
 23685  
 
 23686  40
                     switch (alt132) {
 23687  
                         case 1 :
 23688  
                             // com\\googlecode\\sparkleg\\Sparql.g:652:15: DISTINCT
 23689  
                             {
 23690  0
                             DISTINCT644=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6744);  
 23691  0
                             stream_DISTINCT.add(DISTINCT644);
 23692  6
 
 23693  6
 
 23694  
                             }
 23695  6
                             break;
 23696  
 
 23697  
                     }
 23698  
 
 23699  
 
 23700  46
                     pushFollow(FOLLOW_expression_in_aggregate6747);
 23701  46
                     expression645=expression();
 23702  
 
 23703  40
                     state._fsp--;
 23704  
 
 23705  40
                     stream_expression.add(expression645.getTree());
 23706  6
 
 23707  40
                     char_literal646=(Token)match(input,210,FOLLOW_210_in_aggregate6749);  
 23708  40
                     stream_210.add(char_literal646);
 23709  
 
 23710  
 
 23711  
                     // AST REWRITE
 23712  6
                     // elements: expression, DISTINCT, MAX
 23713  
                     // token labels: 
 23714  6
                     // rule labels: retval
 23715  
                     // token list labels: 
 23716  6
                     // rule list labels: 
 23717  
                     // wildcard labels: 
 23718  40
                     retval.tree = root_0;
 23719  40
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23720  
 
 23721  40
                     root_0 = (Object)adaptor.nil();
 23722  6
                     // 652:40: -> ^( MAX ( DISTINCT )* expression )
 23723  
                     {
 23724  
                         // com\\googlecode\\sparkleg\\Sparql.g:652:43: ^( MAX ( DISTINCT )* expression )
 23725  6
                         {
 23726  40
                         Object root_1 = (Object)adaptor.nil();
 23727  40
                         root_1 = (Object)adaptor.becomeRoot(
 23728  
                         stream_MAX.nextNode()
 23729  6
                         , root_1);
 23730  6
 
 23731  
                         // com\\googlecode\\sparkleg\\Sparql.g:652:49: ( DISTINCT )*
 23732  40
                         while ( stream_DISTINCT.hasNext() ) {
 23733  6
                             adaptor.addChild(root_1, 
 23734  6
                             stream_DISTINCT.nextNode()
 23735  
                             );
 23736  
 
 23737  
                         }
 23738  46
                         stream_DISTINCT.reset();
 23739  6
 
 23740  40
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23741  
 
 23742  40
                         adaptor.addChild(root_0, root_1);
 23743  
                         }
 23744  
 
 23745  
                     }
 23746  
 
 23747  6
 
 23748  40
                     retval.tree = root_0;
 23749  
 
 23750  
                     }
 23751  40
                     break;
 23752  
                 case 5 :
 23753  
                     // com\\googlecode\\sparkleg\\Sparql.g:653:7: AVG '(' ( DISTINCT )? expression ')'
 23754  
                     {
 23755  96
                     AVG647=(Token)match(input,AVG,FOLLOW_AVG_in_aggregate6768);  
 23756  96
                     stream_AVG.add(AVG647);
 23757  
 
 23758  
 
 23759  96
                     char_literal648=(Token)match(input,209,FOLLOW_209_in_aggregate6770);  
 23760  96
                     stream_209.add(char_literal648);
 23761  6
 
 23762  6
 
 23763  
                     // com\\googlecode\\sparkleg\\Sparql.g:653:15: ( DISTINCT )?
 23764  102
                     int alt133=2;
 23765  96
                     switch ( input.LA(1) ) {
 23766  6
                         case DISTINCT:
 23767  
                             {
 23768  0
                             alt133=1;
 23769  6
                             }
 23770  6
                             break;
 23771  
                     }
 23772  
 
 23773  98
                     switch (alt133) {
 23774  
                         case 1 :
 23775  
                             // com\\googlecode\\sparkleg\\Sparql.g:653:15: DISTINCT
 23776  
                             {
 23777  0
                             DISTINCT649=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6772);  
 23778  6
                             stream_DISTINCT.add(DISTINCT649);
 23779  
 
 23780  
 
 23781  
                             }
 23782  2
                             break;
 23783  2
 
 23784  
                     }
 23785  
 
 23786  2
 
 23787  98
                     pushFollow(FOLLOW_expression_in_aggregate6775);
 23788  96
                     expression650=expression();
 23789  
 
 23790  98
                     state._fsp--;
 23791  2
 
 23792  96
                     stream_expression.add(expression650.getTree());
 23793  
 
 23794  98
                     char_literal651=(Token)match(input,210,FOLLOW_210_in_aggregate6777);  
 23795  98
                     stream_210.add(char_literal651);
 23796  
 
 23797  2
 
 23798  
                     // AST REWRITE
 23799  2
                     // elements: AVG, expression, DISTINCT
 23800  
                     // token labels: 
 23801  
                     // rule labels: retval
 23802  
                     // token list labels: 
 23803  
                     // rule list labels: 
 23804  
                     // wildcard labels: 
 23805  96
                     retval.tree = root_0;
 23806  96
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23807  6
 
 23808  102
                     root_0 = (Object)adaptor.nil();
 23809  
                     // 653:40: -> ^( AVG ( DISTINCT )* expression )
 23810  
                     {
 23811  
                         // com\\googlecode\\sparkleg\\Sparql.g:653:43: ^( AVG ( DISTINCT )* expression )
 23812  
                         {
 23813  96
                         Object root_1 = (Object)adaptor.nil();
 23814  96
                         root_1 = (Object)adaptor.becomeRoot(
 23815  
                         stream_AVG.nextNode()
 23816  
                         , root_1);
 23817  
 
 23818  6
                         // com\\googlecode\\sparkleg\\Sparql.g:653:49: ( DISTINCT )*
 23819  102
                         while ( stream_DISTINCT.hasNext() ) {
 23820  0
                             adaptor.addChild(root_1, 
 23821  6
                             stream_DISTINCT.nextNode()
 23822  
                             );
 23823  
 
 23824  
                         }
 23825  96
                         stream_DISTINCT.reset();
 23826  6
 
 23827  102
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23828  
 
 23829  96
                         adaptor.addChild(root_0, root_1);
 23830  
                         }
 23831  
 
 23832  6
                     }
 23833  
 
 23834  
 
 23835  96
                     retval.tree = root_0;
 23836  
 
 23837  
                     }
 23838  102
                     break;
 23839  
                 case 6 :
 23840  6
                     // com\\googlecode\\sparkleg\\Sparql.g:654:7: SAMPLE '(' ( DISTINCT )? expression ')'
 23841  
                     {
 23842  24
                     SAMPLE652=(Token)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate6796);  
 23843  32
                     stream_SAMPLE.add(SAMPLE652);
 23844  2
 
 23845  
 
 23846  24
                     char_literal653=(Token)match(input,209,FOLLOW_209_in_aggregate6798);  
 23847  30
                     stream_209.add(char_literal653);
 23848  
 
 23849  6
 
 23850  
                     // com\\googlecode\\sparkleg\\Sparql.g:654:18: ( DISTINCT )?
 23851  24
                     int alt134=2;
 23852  24
                     switch ( input.LA(1) ) {
 23853  
                         case DISTINCT:
 23854  
                             {
 23855  6
                             alt134=1;
 23856  
                             }
 23857  
                             break;
 23858  
                     }
 23859  
 
 23860  24
                     switch (alt134) {
 23861  106
                         case 1 :
 23862  
                             // com\\googlecode\\sparkleg\\Sparql.g:654:18: DISTINCT
 23863  
                             {
 23864  106
                             DISTINCT654=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6800);  
 23865  106
                             stream_DISTINCT.add(DISTINCT654);
 23866  
 
 23867  
 
 23868  
                             }
 23869  
                             break;
 23870  
 
 23871  
                     }
 23872  
 
 23873  
 
 23874  24
                     pushFollow(FOLLOW_expression_in_aggregate6803);
 23875  24
                     expression655=expression();
 23876  
 
 23877  130
                     state._fsp--;
 23878  106
 
 23879  24
                     stream_expression.add(expression655.getTree());
 23880  
 
 23881  24
                     char_literal656=(Token)match(input,210,FOLLOW_210_in_aggregate6805);  
 23882  24
                     stream_210.add(char_literal656);
 23883  176
 
 23884  
 
 23885  176
                     // AST REWRITE
 23886  
                     // elements: expression, DISTINCT, SAMPLE
 23887  
                     // token labels: 
 23888  
                     // rule labels: retval
 23889  
                     // token list labels: 
 23890  
                     // rule list labels: 
 23891  
                     // wildcard labels: 
 23892  200
                     retval.tree = root_0;
 23893  200
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23894  
 
 23895  24
                     root_0 = (Object)adaptor.nil();
 23896  176
                     // 654:43: -> ^( SAMPLE ( DISTINCT )? expression )
 23897  
                     {
 23898  176
                         // com\\googlecode\\sparkleg\\Sparql.g:654:46: ^( SAMPLE ( DISTINCT )? expression )
 23899  
                         {
 23900  200
                         Object root_1 = (Object)adaptor.nil();
 23901  24
                         root_1 = (Object)adaptor.becomeRoot(
 23902  
                         stream_SAMPLE.nextNode()
 23903  176
                         , root_1);
 23904  176
 
 23905  
                         // com\\googlecode\\sparkleg\\Sparql.g:654:55: ( DISTINCT )?
 23906  24
                         if ( stream_DISTINCT.hasNext() ) {
 23907  0
                             adaptor.addChild(root_1, 
 23908  
                             stream_DISTINCT.nextNode()
 23909  176
                             );
 23910  176
 
 23911  
                         }
 23912  200
                         stream_DISTINCT.reset();
 23913  
 
 23914  200
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23915  
 
 23916  24
                         adaptor.addChild(root_0, root_1);
 23917  176
                         }
 23918  176
 
 23919  
                     }
 23920  
 
 23921  48
 
 23922  24
                     retval.tree = root_0;
 23923  
 
 23924  
                     }
 23925  24
                     break;
 23926  176
                 case 7 :
 23927  
                     // com\\googlecode\\sparkleg\\Sparql.g:655:7: GROUP_CONCAT '(' ( DISTINCT )? expression ( ';' SEPARATOR '=' string )? ')'
 23928  
                     {
 23929  24
                     GROUP_CONCAT657=(Token)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate6824);  
 23930  72
                     stream_GROUP_CONCAT.add(GROUP_CONCAT657);
 23931  48
 
 23932  
 
 23933  72
                     char_literal658=(Token)match(input,209,FOLLOW_209_in_aggregate6826);  
 23934  24
                     stream_209.add(char_literal658);
 23935  48
 
 23936  
 
 23937  
                     // com\\googlecode\\sparkleg\\Sparql.g:655:24: ( DISTINCT )?
 23938  24
                     int alt135=2;
 23939  24
                     switch ( input.LA(1) ) {
 23940  
                         case DISTINCT:
 23941  
                             {
 23942  0
                             alt135=1;
 23943  
                             }
 23944  
                             break;
 23945  
                     }
 23946  
 
 23947  24
                     switch (alt135) {
 23948  
                         case 1 :
 23949  
                             // com\\googlecode\\sparkleg\\Sparql.g:655:24: DISTINCT
 23950  176
                             {
 23951  176
                             DISTINCT659=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6828);  
 23952  0
                             stream_DISTINCT.add(DISTINCT659);
 23953  176
 
 23954  
 
 23955  
                             }
 23956  
                             break;
 23957  
 
 23958  176
                     }
 23959  176
 
 23960  
 
 23961  24
                     pushFollow(FOLLOW_expression_in_aggregate6831);
 23962  24
                     expression660=expression();
 23963  176
 
 23964  24
                     state._fsp--;
 23965  
 
 23966  200
                     stream_expression.add(expression660.getTree());
 23967  
 
 23968  
                     // com\\googlecode\\sparkleg\\Sparql.g:655:45: ( ';' SEPARATOR '=' string )?
 23969  72
                     int alt136=2;
 23970  72
                     switch ( input.LA(1) ) {
 23971  
                         case 212:
 23972  
                             {
 23973  8
                             alt136=1;
 23974  48
                             }
 23975  
                             break;
 23976  48
                     }
 23977  
 
 23978  24
                     switch (alt136) {
 23979  
                         case 1 :
 23980  176
                             // com\\googlecode\\sparkleg\\Sparql.g:655:46: ';' SEPARATOR '=' string
 23981  
                             {
 23982  184
                             char_literal661=(Token)match(input,212,FOLLOW_212_in_aggregate6834);  
 23983  8
                             stream_212.add(char_literal661);
 23984  
 
 23985  
 
 23986  8
                             SEPARATOR662=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_aggregate6836);  
 23987  8
                             stream_SEPARATOR.add(SEPARATOR662);
 23988  176
 
 23989  
 
 23990  8
                             char_literal663=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_aggregate6838);  
 23991  8
                             stream_EQUAL.add(char_literal663);
 23992  176
 
 23993  
 
 23994  8
                             pushFollow(FOLLOW_string_in_aggregate6840);
 23995  184
                             string664=string();
 23996  176
 
 23997  8
                             state._fsp--;
 23998  
 
 23999  8
                             stream_string.add(string664.getTree());
 24000  
 
 24001  
                             }
 24002  
                             break;
 24003  
 
 24004  
                     }
 24005  
 
 24006  
 
 24007  24
                     char_literal665=(Token)match(input,210,FOLLOW_210_in_aggregate6844);  
 24008  200
                     stream_210.add(char_literal665);
 24009  176
 
 24010  
 
 24011  
                     // AST REWRITE
 24012  
                     // elements: string, GROUP_CONCAT, expression, DISTINCT
 24013  
                     // token labels: 
 24014  378
                     // rule labels: retval
 24015  
                     // token list labels: 
 24016  378
                     // rule list labels: 
 24017  
                     // wildcard labels: 
 24018  24
                     retval.tree = root_0;
 24019  24
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 24020  
 
 24021  24
                     root_0 = (Object)adaptor.nil();
 24022  
                     // 655:77: -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 24023  378
                     {
 24024  378
                         // com\\googlecode\\sparkleg\\Sparql.g:655:80: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 24025  
                         {
 24026  24
                         Object root_1 = (Object)adaptor.nil();
 24027  402
                         root_1 = (Object)adaptor.becomeRoot(
 24028  
                         stream_GROUP_CONCAT.nextNode()
 24029  378
                         , root_1);
 24030  378
 
 24031  378
                         // com\\googlecode\\sparkleg\\Sparql.g:655:95: ( DISTINCT )*
 24032  24
                         while ( stream_DISTINCT.hasNext() ) {
 24033  378
                             adaptor.addChild(root_1, 
 24034  
                             stream_DISTINCT.nextNode()
 24035  
                             );
 24036  378
 
 24037  378
                         }
 24038  24
                         stream_DISTINCT.reset();
 24039  
 
 24040  24
                         adaptor.addChild(root_1, stream_expression.nextTree());
 24041  
 
 24042  
                         // com\\googlecode\\sparkleg\\Sparql.g:655:116: ( string )*
 24043  410
                         while ( stream_string.hasNext() ) {
 24044  8
                             adaptor.addChild(root_1, stream_string.nextTree());
 24045  
 
 24046  378
                         }
 24047  402
                         stream_string.reset();
 24048  
 
 24049  402
                         adaptor.addChild(root_0, root_1);
 24050  
                         }
 24051  378
 
 24052  
                     }
 24053  
 
 24054  378
 
 24055  402
                     retval.tree = root_0;
 24056  
 
 24057  
                     }
 24058  10
                     break;
 24059  
 
 24060  10
             }
 24061  424
             retval.stop = input.LT(-1);
 24062  
 
 24063  38
 
 24064  424
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24065  424
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24066  
 
 24067  
         }
 24068  378
         catch (RecognitionException re) {
 24069  0
             reportError(re);
 24070  0
             recover(input,re);
 24071  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24072  10
 
 24073  10
         }
 24074  
 
 24075  0
         finally {
 24076  10
                 // do for sure before leaving
 24077  424
         }
 24078  424
         return retval;
 24079  
     }
 24080  10
     // $ANTLR end "aggregate"
 24081  
 
 24082  
 
 24083  704
     public static class iriRefOrFunction_return extends ParserRuleReturnScope {
 24084  
         Object tree;
 24085  704
         public Object getTree() { return tree; }
 24086  
     };
 24087  38
 
 24088  38
 
 24089  
     // $ANTLR start "iriRefOrFunction"
 24090  
     // com\\googlecode\\sparkleg\\Sparql.g:658:1: iriRefOrFunction : iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) ;
 24091  38
     public final SparqlParser.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 24092  704
         SparqlParser.iriRefOrFunction_return retval = new SparqlParser.iriRefOrFunction_return();
 24093  704
         retval.start = input.LT(1);
 24094  38
 
 24095  38
 
 24096  704
         Object root_0 = null;
 24097  38
 
 24098  704
         SparqlParser.iriRef_return iriRef666 =null;
 24099  38
 
 24100  704
         SparqlParser.argList_return argList667 =null;
 24101  
 
 24102  
 
 24103  704
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 24104  704
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 24105  
         try {
 24106  
             // com\\googlecode\\sparkleg\\Sparql.g:659:5: ( iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) )
 24107  
             // com\\googlecode\\sparkleg\\Sparql.g:659:7: iriRef ( argList )?
 24108  
             {
 24109  704
             pushFollow(FOLLOW_iriRef_in_iriRefOrFunction6879);
 24110  704
             iriRef666=iriRef();
 24111  
 
 24112  1082
             state._fsp--;
 24113  
 
 24114  704
             stream_iriRef.add(iriRef666.getTree());
 24115  378
 
 24116  378
             // com\\googlecode\\sparkleg\\Sparql.g:659:14: ( argList )?
 24117  704
             int alt138=2;
 24118  704
             switch ( input.LA(1) ) {
 24119  
                 case 209:
 24120  
                     {
 24121  384
                     alt138=1;
 24122  
                     }
 24123  
                     break;
 24124  
             }
 24125  
 
 24126  704
             switch (alt138) {
 24127  
                 case 1 :
 24128  378
                     // com\\googlecode\\sparkleg\\Sparql.g:659:14: argList
 24129  378
                     {
 24130  384
                     pushFollow(FOLLOW_argList_in_iriRefOrFunction6881);
 24131  384
                     argList667=argList();
 24132  
 
 24133  384
                     state._fsp--;
 24134  282
 
 24135  384
                     stream_argList.add(argList667.getTree());
 24136  282
 
 24137  
                     }
 24138  
                     break;
 24139  
 
 24140  
             }
 24141  
 
 24142  
 
 24143  282
             // AST REWRITE
 24144  282
             // elements: argList, iriRef
 24145  
             // token labels: 
 24146  
             // rule labels: retval
 24147  282
             // token list labels: 
 24148  
             // rule list labels: 
 24149  282
             // wildcard labels: 
 24150  704
             retval.tree = root_0;
 24151  986
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 24152  
 
 24153  986
             root_0 = (Object)adaptor.nil();
 24154  
             // 659:23: -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 24155  
             {
 24156  
                 // com\\googlecode\\sparkleg\\Sparql.g:659:26: ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 24157  
                 {
 24158  704
                 Object root_1 = (Object)adaptor.nil();
 24159  986
                 root_1 = (Object)adaptor.becomeRoot(
 24160  282
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 24161  
                 , root_1);
 24162  
 
 24163  704
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 24164  
 
 24165  256
                 // com\\googlecode\\sparkleg\\Sparql.g:659:44: ( ^( ARG_LIST argList ) )?
 24166  704
                 if ( stream_argList.hasNext() ) {
 24167  256
                     // com\\googlecode\\sparkleg\\Sparql.g:659:44: ^( ARG_LIST argList )
 24168  
                     {
 24169  384
                     Object root_2 = (Object)adaptor.nil();
 24170  384
                     root_2 = (Object)adaptor.becomeRoot(
 24171  
                     (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 24172  10
                     , root_2);
 24173  
 
 24174  394
                     adaptor.addChild(root_2, stream_argList.nextTree());
 24175  
 
 24176  384
                     adaptor.addChild(root_1, root_2);
 24177  
                     }
 24178  
 
 24179  16
                 }
 24180  704
                 stream_argList.reset();
 24181  16
 
 24182  704
                 adaptor.addChild(root_0, root_1);
 24183  
                 }
 24184  
 
 24185  
             }
 24186  
 
 24187  
 
 24188  704
             retval.tree = root_0;
 24189  
 
 24190  282
             }
 24191  
 
 24192  704
             retval.stop = input.LT(-1);
 24193  
 
 24194  256
 
 24195  704
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24196  704
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24197  256
 
 24198  256
         }
 24199  0
         catch (RecognitionException re) {
 24200  256
             reportError(re);
 24201  0
             recover(input,re);
 24202  256
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24203  
 
 24204  
         }
 24205  256
 
 24206  0
         finally {
 24207  
                 // do for sure before leaving
 24208  704
         }
 24209  714
         return retval;
 24210  
     }
 24211  
     // $ANTLR end "iriRefOrFunction"
 24212  10
 
 24213  10
 
 24214  1512
     public static class rdfLiteral_return extends ParserRuleReturnScope {
 24215  10
         Object tree;
 24216  1512
         public Object getTree() { return tree; }
 24217  10
     };
 24218  
 
 24219  
 
 24220  10
     // $ANTLR start "rdfLiteral"
 24221  
     // com\\googlecode\\sparkleg\\Sparql.g:662:1: rdfLiteral : string ( LANGTAG | ( '^^' iriRef ) )? -> ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* ) ;
 24222  
     public final SparqlParser.rdfLiteral_return rdfLiteral() throws RecognitionException {
 24223  1512
         SparqlParser.rdfLiteral_return retval = new SparqlParser.rdfLiteral_return();
 24224  1528
         retval.start = input.LT(1);
 24225  
 
 24226  
 
 24227  1528
         Object root_0 = null;
 24228  16
 
 24229  1512
         Token LANGTAG669=null;
 24230  1528
         Token string_literal670=null;
 24231  1512
         SparqlParser.string_return string668 =null;
 24232  16
 
 24233  1512
         SparqlParser.iriRef_return iriRef671 =null;
 24234  
 
 24235  
 
 24236  1512
         Object LANGTAG669_tree=null;
 24237  1512
         Object string_literal670_tree=null;
 24238  1794
         RewriteRuleTokenStream stream_215=new RewriteRuleTokenStream(adaptor,"token 215");
 24239  1512
         RewriteRuleTokenStream stream_LANGTAG=new RewriteRuleTokenStream(adaptor,"token LANGTAG");
 24240  1512
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 24241  1794
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 24242  282
         try {
 24243  
             // com\\googlecode\\sparkleg\\Sparql.g:663:5: ( string ( LANGTAG | ( '^^' iriRef ) )? -> ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* ) )
 24244  
             // com\\googlecode\\sparkleg\\Sparql.g:663:7: string ( LANGTAG | ( '^^' iriRef ) )?
 24245  
             {
 24246  1512
             pushFollow(FOLLOW_string_in_rdfLiteral6914);
 24247  1512
             string668=string();
 24248  
 
 24249  1512
             state._fsp--;
 24250  
 
 24251  1512
             stream_string.add(string668.getTree());
 24252  
 
 24253  
             // com\\googlecode\\sparkleg\\Sparql.g:663:14: ( LANGTAG | ( '^^' iriRef ) )?
 24254  1794
             int alt139=3;
 24255  1794
             switch ( input.LA(1) ) {
 24256  
                 case LANGTAG:
 24257  
                     {
 24258  40
                     alt139=1;
 24259  
                     }
 24260  40
                     break;
 24261  
                 case 215:
 24262  256
                     {
 24263  152
                     alt139=2;
 24264  
                     }
 24265  
                     break;
 24266  
             }
 24267  
 
 24268  1512
             switch (alt139) {
 24269  256
                 case 1 :
 24270  256
                     // com\\googlecode\\sparkleg\\Sparql.g:663:15: LANGTAG
 24271  
                     {
 24272  40
                     LANGTAG669=(Token)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral6917);  
 24273  296
                     stream_LANGTAG.add(LANGTAG669);
 24274  
 
 24275  256
 
 24276  
                     }
 24277  296
                     break;
 24278  
                 case 2 :
 24279  
                     // com\\googlecode\\sparkleg\\Sparql.g:663:25: ( '^^' iriRef )
 24280  
                     {
 24281  
                     // com\\googlecode\\sparkleg\\Sparql.g:663:25: ( '^^' iriRef )
 24282  
                     // com\\googlecode\\sparkleg\\Sparql.g:663:26: '^^' iriRef
 24283  256
                     {
 24284  152
                     string_literal670=(Token)match(input,215,FOLLOW_215_in_rdfLiteral6922);  
 24285  152
                     stream_215.add(string_literal670);
 24286  256
 
 24287  
 
 24288  408
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral6924);
 24289  408
                     iriRef671=iriRef();
 24290  256
 
 24291  152
                     state._fsp--;
 24292  
 
 24293  408
                     stream_iriRef.add(iriRef671.getTree());
 24294  
 
 24295  
                     }
 24296  
 
 24297  
 
 24298  
                     }
 24299  
                     break;
 24300  
 
 24301  
             }
 24302  
 
 24303  256
 
 24304  
             // AST REWRITE
 24305  
             // elements: string, iriRef, LANGTAG
 24306  256
             // token labels: 
 24307  256
             // rule labels: retval
 24308  
             // token list labels: 
 24309  
             // rule list labels: 
 24310  
             // wildcard labels: 
 24311  1512
             retval.tree = root_0;
 24312  1512
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 24313  
 
 24314  1512
             root_0 = (Object)adaptor.nil();
 24315  
             // 663:41: -> ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* )
 24316  
             {
 24317  
                 // com\\googlecode\\sparkleg\\Sparql.g:663:44: ^( RDFLITERAL string ( LANGTAG )* ( iriRef )* )
 24318  
                 {
 24319  1768
                 Object root_1 = (Object)adaptor.nil();
 24320  1768
                 root_1 = (Object)adaptor.becomeRoot(
 24321  
                 (Object)adaptor.create(RDFLITERAL, "RDFLITERAL")
 24322  
                 , root_1);
 24323  
 
 24324  1512
                 adaptor.addChild(root_1, stream_string.nextTree());
 24325  50
 
 24326  
                 // com\\googlecode\\sparkleg\\Sparql.g:663:64: ( LANGTAG )*
 24327  1552
                 while ( stream_LANGTAG.hasNext() ) {
 24328  40
                     adaptor.addChild(root_1, 
 24329  
                     stream_LANGTAG.nextNode()
 24330  
                     );
 24331  
 
 24332  
                 }
 24333  1512
                 stream_LANGTAG.reset();
 24334  50
 
 24335  50
                 // com\\googlecode\\sparkleg\\Sparql.g:663:73: ( iriRef )*
 24336  1664
                 while ( stream_iriRef.hasNext() ) {
 24337  152
                     adaptor.addChild(root_1, stream_iriRef.nextTree());
 24338  50
 
 24339  
                 }
 24340  1562
                 stream_iriRef.reset();
 24341  
 
 24342  1562
                 adaptor.addChild(root_0, root_1);
 24343  
                 }
 24344  
 
 24345  
             }
 24346  
 
 24347  
 
 24348  1562
             retval.tree = root_0;
 24349  
 
 24350  
             }
 24351  50
 
 24352  1512
             retval.stop = input.LT(-1);
 24353  50
 
 24354  50
 
 24355  1562
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24356  1512
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24357  
 
 24358  50
         }
 24359  0
         catch (RecognitionException re) {
 24360  0
             reportError(re);
 24361  0
             recover(input,re);
 24362  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24363  
 
 24364  
         }
 24365  
 
 24366  0
         finally {
 24367  
                 // do for sure before leaving
 24368  1562
         }
 24369  1512
         return retval;
 24370  
     }
 24371  50
     // $ANTLR end "rdfLiteral"
 24372  50
 
 24373  
 
 24374  1182
     public static class numericLiteral_return extends ParserRuleReturnScope {
 24375  
         Object tree;
 24376  1182
         public Object getTree() { return tree; }
 24377  
     };
 24378  
 
 24379  
 
 24380  
     // $ANTLR start "numericLiteral"
 24381  
     // com\\googlecode\\sparkleg\\Sparql.g:666:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 24382  
     public final SparqlParser.numericLiteral_return numericLiteral() throws RecognitionException {
 24383  1182
         SparqlParser.numericLiteral_return retval = new SparqlParser.numericLiteral_return();
 24384  1232
         retval.start = input.LT(1);
 24385  50
 
 24386  
 
 24387  1182
         Object root_0 = null;
 24388  
 
 24389  1182
         SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned672 =null;
 24390  16
 
 24391  1182
         SparqlParser.numericLiteralPositive_return numericLiteralPositive673 =null;
 24392  16
 
 24393  1182
         SparqlParser.numericLiteralNegative_return numericLiteralNegative674 =null;
 24394  
 
 24395  
 
 24396  
 
 24397  
         try {
 24398  
             // com\\googlecode\\sparkleg\\Sparql.g:667:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 24399  1198
             int alt140=3;
 24400  1198
             switch ( input.LA(1) ) {
 24401  
             case DECIMAL:
 24402  
             case DOUBLE:
 24403  16
             case INTEGER:
 24404  
                 {
 24405  1034
                 alt140=1;
 24406  
                 }
 24407  1034
                 break;
 24408  
             case DECIMAL_POSITIVE:
 24409  
             case DOUBLE_POSITIVE:
 24410  
             case INTEGER_POSITIVE:
 24411  
                 {
 24412  100
                 alt140=2;
 24413  16
                 }
 24414  100
                 break;
 24415  
             case DECIMAL_NEGATIVE:
 24416  16
             case DOUBLE_NEGATIVE:
 24417  
             case INTEGER_NEGATIVE:
 24418  16
                 {
 24419  80
                 alt140=3;
 24420  16
                 }
 24421  64
                 break;
 24422  
             default:
 24423  16
                 NoViableAltException nvae =
 24424  
                     new NoViableAltException("", 140, 0, input);
 24425  
 
 24426  0
                 throw nvae;
 24427  
 
 24428  
             }
 24429  
 
 24430  1182
             switch (alt140) {
 24431  
                 case 1 :
 24432  
                     // com\\googlecode\\sparkleg\\Sparql.g:667:7: numericLiteralUnsigned
 24433  16
                     {
 24434  1018
                     root_0 = (Object)adaptor.nil();
 24435  
 
 24436  16
 
 24437  1034
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral6958);
 24438  1018
                     numericLiteralUnsigned672=numericLiteralUnsigned();
 24439  
 
 24440  1018
                     state._fsp--;
 24441  
 
 24442  1018
                     adaptor.addChild(root_0, numericLiteralUnsigned672.getTree());
 24443  
 
 24444  
                     }
 24445  1018
                     break;
 24446  
                 case 2 :
 24447  
                     // com\\googlecode\\sparkleg\\Sparql.g:668:7: numericLiteralPositive
 24448  
                     {
 24449  116
                     root_0 = (Object)adaptor.nil();
 24450  16
 
 24451  
 
 24452  100
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral6966);
 24453  100
                     numericLiteralPositive673=numericLiteralPositive();
 24454  
 
 24455  100
                     state._fsp--;
 24456  
 
 24457  100
                     adaptor.addChild(root_0, numericLiteralPositive673.getTree());
 24458  
 
 24459  
                     }
 24460  100
                     break;
 24461  
                 case 3 :
 24462  
                     // com\\googlecode\\sparkleg\\Sparql.g:669:7: numericLiteralNegative
 24463  
                     {
 24464  80
                     root_0 = (Object)adaptor.nil();
 24465  16
 
 24466  
 
 24467  64
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral6974);
 24468  80
                     numericLiteralNegative674=numericLiteralNegative();
 24469  
 
 24470  80
                     state._fsp--;
 24471  
 
 24472  80
                     adaptor.addChild(root_0, numericLiteralNegative674.getTree());
 24473  
 
 24474  
                     }
 24475  
                     break;
 24476  
 
 24477  
             }
 24478  1198
             retval.stop = input.LT(-1);
 24479  
 
 24480  
 
 24481  1198
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24482  1182
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24483  16
 
 24484  16
         }
 24485  16
         catch (RecognitionException re) {
 24486  0
             reportError(re);
 24487  0
             recover(input,re);
 24488  16
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24489  
 
 24490  
         }
 24491  
 
 24492  0
         finally {
 24493  
                 // do for sure before leaving
 24494  1182
         }
 24495  1182
         return retval;
 24496  
     }
 24497  
     // $ANTLR end "numericLiteral"
 24498  16
 
 24499  
 
 24500  1018
     public static class numericLiteralUnsigned_return extends ParserRuleReturnScope {
 24501  16
         Object tree;
 24502  16
         public Object getTree() { return tree; }
 24503  
     };
 24504  
 
 24505  
 
 24506  
     // $ANTLR start "numericLiteralUnsigned"
 24507  
     // com\\googlecode\\sparkleg\\Sparql.g:672:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 24508  
     public final SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 24509  1018
         SparqlParser.numericLiteralUnsigned_return retval = new SparqlParser.numericLiteralUnsigned_return();
 24510  1018
         retval.start = input.LT(1);
 24511  
 
 24512  
 
 24513  1018
         Object root_0 = null;
 24514  16
 
 24515  1034
         Token set675=null;
 24516  
 
 24517  1018
         Object set675_tree=null;
 24518  
 
 24519  
         try {
 24520  380
             // com\\googlecode\\sparkleg\\Sparql.g:673:5: ( INTEGER | DECIMAL | DOUBLE )
 24521  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24522  380
             {
 24523  1018
             root_0 = (Object)adaptor.nil();
 24524  
 
 24525  
 
 24526  1018
             set675=(Token)input.LT(1);
 24527  
 
 24528  1018
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 24529  1398
                 input.consume();
 24530  1398
                 adaptor.addChild(root_0, 
 24531  
                 (Object)adaptor.create(set675)
 24532  
                 );
 24533  1398
                 state.errorRecovery=false;
 24534  
             }
 24535  380
             else {
 24536  0
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24537  380
                 throw mse;
 24538  
             }
 24539  
 
 24540  
 
 24541  
             }
 24542  
 
 24543  1398
             retval.stop = input.LT(-1);
 24544  
 
 24545  
 
 24546  1398
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24547  1018
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24548  380
 
 24549  380
         }
 24550  380
         catch (RecognitionException re) {
 24551  0
             reportError(re);
 24552  0
             recover(input,re);
 24553  380
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24554  
 
 24555  
         }
 24556  
 
 24557  0
         finally {
 24558  
                 // do for sure before leaving
 24559  1018
         }
 24560  1018
         return retval;
 24561  
     }
 24562  
     // $ANTLR end "numericLiteralUnsigned"
 24563  380
 
 24564  
 
 24565  200
     public static class numericLiteralPositive_return extends ParserRuleReturnScope {
 24566  380
         Object tree;
 24567  380
         public Object getTree() { return tree; }
 24568  
     };
 24569  
 
 24570  
 
 24571  
     // $ANTLR start "numericLiteralPositive"
 24572  
     // com\\googlecode\\sparkleg\\Sparql.g:678:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 24573  
     public final SparqlParser.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 24574  200
         SparqlParser.numericLiteralPositive_return retval = new SparqlParser.numericLiteralPositive_return();
 24575  200
         retval.start = input.LT(1);
 24576  
 
 24577  
 
 24578  200
         Object root_0 = null;
 24579  380
 
 24580  580
         Token set676=null;
 24581  
 
 24582  200
         Object set676_tree=null;
 24583  
 
 24584  
         try {
 24585  4350
             // com\\googlecode\\sparkleg\\Sparql.g:679:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 24586  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24587  4350
             {
 24588  200
             root_0 = (Object)adaptor.nil();
 24589  
 
 24590  
 
 24591  200
             set676=(Token)input.LT(1);
 24592  
 
 24593  200
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 24594  4550
                 input.consume();
 24595  4550
                 adaptor.addChild(root_0, 
 24596  
                 (Object)adaptor.create(set676)
 24597  
                 );
 24598  4550
                 state.errorRecovery=false;
 24599  
             }
 24600  4350
             else {
 24601  4350
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24602  0
                 throw mse;
 24603  
             }
 24604  4350
 
 24605  
 
 24606  
             }
 24607  
 
 24608  4550
             retval.stop = input.LT(-1);
 24609  4350
 
 24610  
 
 24611  200
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24612  672
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24613  
 
 24614  472
         }
 24615  0
         catch (RecognitionException re) {
 24616  0
             reportError(re);
 24617  0
             recover(input,re);
 24618  3878
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24619  
 
 24620  3878
         }
 24621  
 
 24622  0
         finally {
 24623  
                 // do for sure before leaving
 24624  200
         }
 24625  200
         return retval;
 24626  
     }
 24627  
     // $ANTLR end "numericLiteralPositive"
 24628  
 
 24629  4350
 
 24630  64
     public static class numericLiteralNegative_return extends ParserRuleReturnScope {
 24631  
         Object tree;
 24632  64
         public Object getTree() { return tree; }
 24633  472
     };
 24634  
 
 24635  
 
 24636  472
     // $ANTLR start "numericLiteralNegative"
 24637  472
     // com\\googlecode\\sparkleg\\Sparql.g:684:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 24638  
     public final SparqlParser.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 24639  64
         SparqlParser.numericLiteralNegative_return retval = new SparqlParser.numericLiteralNegative_return();
 24640  536
         retval.start = input.LT(1);
 24641  
 
 24642  
 
 24643  64
         Object root_0 = null;
 24644  472
 
 24645  64
         Token set677=null;
 24646  
 
 24647  64
         Object set677_tree=null;
 24648  3878
 
 24649  
         try {
 24650  
             // com\\googlecode\\sparkleg\\Sparql.g:685:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 24651  3878
             // com\\googlecode\\sparkleg\\Sparql.g:
 24652  3878
             {
 24653  64
             root_0 = (Object)adaptor.nil();
 24654  3878
 
 24655  
 
 24656  3942
             set677=(Token)input.LT(1);
 24657  
 
 24658  64
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 24659  64
                 input.consume();
 24660  64
                 adaptor.addChild(root_0, 
 24661  
                 (Object)adaptor.create(set677)
 24662  4350
                 );
 24663  64
                 state.errorRecovery=false;
 24664  
             }
 24665  4350
             else {
 24666  4350
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24667  0
                 throw mse;
 24668  
             }
 24669  
 
 24670  
 
 24671  
             }
 24672  
 
 24673  64
             retval.stop = input.LT(-1);
 24674  
 
 24675  
 
 24676  64
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24677  64
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24678  4350
 
 24679  4350
         }
 24680  0
         catch (RecognitionException re) {
 24681  0
             reportError(re);
 24682  0
             recover(input,re);
 24683  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24684  3878
 
 24685  
         }
 24686  3878
 
 24687  0
         finally {
 24688  
                 // do for sure before leaving
 24689  64
         }
 24690  64
         return retval;
 24691  
     }
 24692  
     // $ANTLR end "numericLiteralNegative"
 24693  3878
 
 24694  3878
 
 24695  64
     public static class booleanLiteral_return extends ParserRuleReturnScope {
 24696  
         Object tree;
 24697  3878
         public Object getTree() { return tree; }
 24698  
     };
 24699  3878
 
 24700  
 
 24701  3878
     // $ANTLR start "booleanLiteral"
 24702  
     // com\\googlecode\\sparkleg\\Sparql.g:690:1: booleanLiteral : ( TRUE | FALSE );
 24703  
     public final SparqlParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
 24704  64
         SparqlParser.booleanLiteral_return retval = new SparqlParser.booleanLiteral_return();
 24705  64
         retval.start = input.LT(1);
 24706  
 
 24707  3878
 
 24708  64
         Object root_0 = null;
 24709  
 
 24710  3942
         Token set678=null;
 24711  
 
 24712  3942
         Object set678_tree=null;
 24713  3878
 
 24714  3878
         try {
 24715  
             // com\\googlecode\\sparkleg\\Sparql.g:691:5: ( TRUE | FALSE )
 24716  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24717  3878
             {
 24718  64
             root_0 = (Object)adaptor.nil();
 24719  
 
 24720  
 
 24721  64
             set678=(Token)input.LT(1);
 24722  
 
 24723  64
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 24724  64
                 input.consume();
 24725  64
                 adaptor.addChild(root_0, 
 24726  
                 (Object)adaptor.create(set678)
 24727  3878
                 );
 24728  64
                 state.errorRecovery=false;
 24729  
             }
 24730  3878
             else {
 24731  3878
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24732  0
                 throw mse;
 24733  
             }
 24734  
 
 24735  
 
 24736  
             }
 24737  
 
 24738  64
             retval.stop = input.LT(-1);
 24739  
 
 24740  
 
 24741  64
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24742  64
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24743  3878
 
 24744  3878
         }
 24745  0
         catch (RecognitionException re) {
 24746  0
             reportError(re);
 24747  0
             recover(input,re);
 24748  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24749  204
 
 24750  
         }
 24751  204
 
 24752  0
         finally {
 24753  
                 // do for sure before leaving
 24754  64
         }
 24755  64
         return retval;
 24756  
     }
 24757  
     // $ANTLR end "booleanLiteral"
 24758  204
 
 24759  204
 
 24760  1520
     public static class string_return extends ParserRuleReturnScope {
 24761  
         Object tree;
 24762  1520
         public Object getTree() { return tree; }
 24763  
     };
 24764  204
 
 24765  204
 
 24766  
     // $ANTLR start "string"
 24767  
     // com\\googlecode\\sparkleg\\Sparql.g:695:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 24768  204
     public final SparqlParser.string_return string() throws RecognitionException {
 24769  1520
         SparqlParser.string_return retval = new SparqlParser.string_return();
 24770  1520
         retval.start = input.LT(1);
 24771  
 
 24772  204
 
 24773  1724
         Object root_0 = null;
 24774  
 
 24775  1520
         Token set679=null;
 24776  116
 
 24777  1520
         Object set679_tree=null;
 24778  116
 
 24779  
         try {
 24780  
             // com\\googlecode\\sparkleg\\Sparql.g:696:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 24781  88
             // com\\googlecode\\sparkleg\\Sparql.g:
 24782  
             {
 24783  1608
             root_0 = (Object)adaptor.nil();
 24784  
 
 24785  
 
 24786  1520
             set679=(Token)input.LT(1);
 24787  
 
 24788  1520
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 24789  1520
                 input.consume();
 24790  1520
                 adaptor.addChild(root_0, 
 24791  
                 (Object)adaptor.create(set679)
 24792  204
                 );
 24793  1520
                 state.errorRecovery=false;
 24794  
             }
 24795  
             else {
 24796  116
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24797  0
                 throw mse;
 24798  
             }
 24799  116
 
 24800  116
 
 24801  
             }
 24802  
 
 24803  1636
             retval.stop = input.LT(-1);
 24804  
 
 24805  
 
 24806  1520
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24807  1636
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24808  
 
 24809  
         }
 24810  0
         catch (RecognitionException re) {
 24811  88
             reportError(re);
 24812  0
             recover(input,re);
 24813  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24814  88
 
 24815  88
         }
 24816  
 
 24817  88
         finally {
 24818  
                 // do for sure before leaving
 24819  1608
         }
 24820  1520
         return retval;
 24821  
     }
 24822  
     // $ANTLR end "string"
 24823  
 
 24824  
 
 24825  17241
     public static class iriRef_return extends ParserRuleReturnScope {
 24826  
         Object tree;
 24827  17241
         public Object getTree() { return tree; }
 24828  204
     };
 24829  204
 
 24830  
 
 24831  
     // $ANTLR start "iriRef"
 24832  
     // com\\googlecode\\sparkleg\\Sparql.g:702:1: iriRef : ( IRI_REF | prefixedName );
 24833  
     public final SparqlParser.iriRef_return iriRef() throws RecognitionException {
 24834  17241
         SparqlParser.iriRef_return retval = new SparqlParser.iriRef_return();
 24835  17241
         retval.start = input.LT(1);
 24836  
 
 24837  
 
 24838  17241
         Object root_0 = null;
 24839  
 
 24840  17241
         Token IRI_REF680=null;
 24841  17445
         SparqlParser.prefixedName_return prefixedName681 =null;
 24842  204
 
 24843  
 
 24844  17241
         Object IRI_REF680_tree=null;
 24845  
 
 24846  
         try {
 24847  88
             // com\\googlecode\\sparkleg\\Sparql.g:703:5: ( IRI_REF | prefixedName )
 24848  17241
             int alt141=2;
 24849  17241
             switch ( input.LA(1) ) {
 24850  
             case IRI_REF:
 24851  
                 {
 24852  1864
                 alt141=1;
 24853  
                 }
 24854  1864
                 break;
 24855  
             case PNAME_LN:
 24856  88
             case PNAME_NS:
 24857  88
                 {
 24858  15377
                 alt141=2;
 24859  
                 }
 24860  15465
                 break;
 24861  
             default:
 24862  88
                 NoViableAltException nvae =
 24863  88
                     new NoViableAltException("", 141, 0, input);
 24864  
 
 24865  88
                 throw nvae;
 24866  88
 
 24867  
             }
 24868  
 
 24869  17241
             switch (alt141) {
 24870  
                 case 1 :
 24871  
                     // com\\googlecode\\sparkleg\\Sparql.g:703:7: IRI_REF
 24872  88
                     {
 24873  1864
                     root_0 = (Object)adaptor.nil();
 24874  
 
 24875  88
 
 24876  1952
                     IRI_REF680=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef7157); 
 24877  1864
                     IRI_REF680_tree = 
 24878  
                     (Object)adaptor.create(IRI_REF680)
 24879  88
                     ;
 24880  1864
                     adaptor.addChild(root_0, IRI_REF680_tree);
 24881  
 
 24882  88
 
 24883  88
                     }
 24884  1864
                     break;
 24885  
                 case 2 :
 24886  88
                     // com\\googlecode\\sparkleg\\Sparql.g:704:7: prefixedName
 24887  
                     {
 24888  15377
                     root_0 = (Object)adaptor.nil();
 24889  
 
 24890  
 
 24891  15465
                     pushFollow(FOLLOW_prefixedName_in_iriRef7165);
 24892  15377
                     prefixedName681=prefixedName();
 24893  
 
 24894  15465
                     state._fsp--;
 24895  88
 
 24896  15377
                     adaptor.addChild(root_0, prefixedName681.getTree());
 24897  
 
 24898  
                     }
 24899  
                     break;
 24900  
 
 24901  
             }
 24902  17241
             retval.stop = input.LT(-1);
 24903  
 
 24904  
 
 24905  17241
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24906  17241
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24907  88
 
 24908  88
         }
 24909  0
         catch (RecognitionException re) {
 24910  0
             reportError(re);
 24911  0
             recover(input,re);
 24912  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24913  
 
 24914  
         }
 24915  1958
 
 24916  0
         finally {
 24917  
                 // do for sure before leaving
 24918  17241
         }
 24919  17241
         return retval;
 24920  
     }
 24921  
     // $ANTLR end "iriRef"
 24922  
 
 24923  
 
 24924  15377
     public static class prefixedName_return extends ParserRuleReturnScope {
 24925  
         Object tree;
 24926  15377
         public Object getTree() { return tree; }
 24927  
     };
 24928  2
 
 24929  
 
 24930  
     // $ANTLR start "prefixedName"
 24931  
     // com\\googlecode\\sparkleg\\Sparql.g:707:1: prefixedName : ( PNAME_LN | PNAME_NS );
 24932  
     public final SparqlParser.prefixedName_return prefixedName() throws RecognitionException {
 24933  15377
         SparqlParser.prefixedName_return retval = new SparqlParser.prefixedName_return();
 24934  15377
         retval.start = input.LT(1);
 24935  
 
 24936  
 
 24937  15377
         Object root_0 = null;
 24938  
 
 24939  15377
         Token set682=null;
 24940  
 
 24941  15377
         Object set682_tree=null;
 24942  
 
 24943  
         try {
 24944  
             // com\\googlecode\\sparkleg\\Sparql.g:708:5: ( PNAME_LN | PNAME_NS )
 24945  
             // com\\googlecode\\sparkleg\\Sparql.g:
 24946  
             {
 24947  15377
             root_0 = (Object)adaptor.nil();
 24948  2
 
 24949  2
 
 24950  15379
             set682=(Token)input.LT(1);
 24951  2
 
 24952  15379
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 24953  15379
                 input.consume();
 24954  15377
                 adaptor.addChild(root_0, 
 24955  
                 (Object)adaptor.create(set682)
 24956  
                 );
 24957  15379
                 state.errorRecovery=false;
 24958  2
             }
 24959  18
             else {
 24960  16
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24961  0
                 throw mse;
 24962  
             }
 24963  
 
 24964  
 
 24965  
             }
 24966  1958
 
 24967  15377
             retval.stop = input.LT(-1);
 24968  1958
 
 24969  1958
 
 24970  15377
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24971  15377
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24972  1958
 
 24973  1958
         }
 24974  0
         catch (RecognitionException re) {
 24975  0
             reportError(re);
 24976  0
             recover(input,re);
 24977  0
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24978  
 
 24979  
         }
 24980  
 
 24981  0
         finally {
 24982  
                 // do for sure before leaving
 24983  15379
         }
 24984  15379
         return retval;
 24985  2
     }
 24986  2
     // $ANTLR end "prefixedName"
 24987  2
 
 24988  2
 
 24989  2
     public static class blankNode_return extends ParserRuleReturnScope {
 24990  2
         Object tree;
 24991  2
         public Object getTree() { return tree; }
 24992  2
     };
 24993  2
 
 24994  2
 
 24995  2
     // $ANTLR start "blankNode"
 24996  2
     // com\\googlecode\\sparkleg\\Sparql.g:712:1: blankNode : ( BLANK_NODE_LABEL | anon );
 24997  2
     public final SparqlParser.blankNode_return blankNode() throws RecognitionException {
 24998  782
         SparqlParser.blankNode_return retval = new SparqlParser.blankNode_return();
 24999  782
         retval.start = input.LT(1);
 25000  2
 
 25001  2
 
 25002  782
         Object root_0 = null;
 25003  2
 
 25004  782
         Token BLANK_NODE_LABEL683=null;
 25005  782
         SparqlParser.anon_return anon684 =null;
 25006  2
 
 25007  2
 
 25008  782
         Object BLANK_NODE_LABEL683_tree=null;
 25009  2
 
 25010  2
         try {
 25011  2
             // com\\googlecode\\sparkleg\\Sparql.g:713:5: ( BLANK_NODE_LABEL | anon )
 25012  782
             int alt142=2;
 25013  782
             switch ( input.LA(1) ) {
 25014  2
             case BLANK_NODE_LABEL:
 25015  2
                 {
 25016  442
                 alt142=1;
 25017  2
                 }
 25018  442
                 break;
 25019  2
             case 213:
 25020  2
                 {
 25021  342
                 alt142=2;
 25022  2
                 }
 25023  342
                 break;
 25024  2
             default:
 25025  2
                 NoViableAltException nvae =
 25026  2
                     new NoViableAltException("", 142, 0, input);
 25027  2
 
 25028  2
                 throw nvae;
 25029  2
 
 25030  2
             }
 25031  2
 
 25032  782
             switch (alt142) {
 25033  2
                 case 1 :
 25034  2
                     // com\\googlecode\\sparkleg\\Sparql.g:713:7: BLANK_NODE_LABEL
 25035  2
                     {
 25036  442
                     root_0 = (Object)adaptor.nil();
 25037  2
 
 25038  2
 
 25039  442
                     BLANK_NODE_LABEL683=(Token)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode7207); 
 25040  442
                     BLANK_NODE_LABEL683_tree = 
 25041  2
                     (Object)adaptor.create(BLANK_NODE_LABEL683)
 25042  2
                     ;
 25043  442
                     adaptor.addChild(root_0, BLANK_NODE_LABEL683_tree);
 25044  2
 
 25045  2
 
 25046  2
                     }
 25047  442
                     break;
 25048  2
                 case 2 :
 25049  2
                     // com\\googlecode\\sparkleg\\Sparql.g:714:7: anon
 25050  2
                     {
 25051  342
                     root_0 = (Object)adaptor.nil();
 25052  2
 
 25053  2
 
 25054  342
                     pushFollow(FOLLOW_anon_in_blankNode7215);
 25055  342
                     anon684=anon();
 25056  2
 
 25057  342
                     state._fsp--;
 25058  2
 
 25059  342
                     adaptor.addChild(root_0, anon684.getTree());
 25060  2
 
 25061  2
                     }
 25062  2
                     break;
 25063  2
 
 25064  2
             }
 25065  782
             retval.stop = input.LT(-1);
 25066  2
 
 25067  2
 
 25068  782
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 25069  782
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 25070  2
 
 25071  2
         }
 25072  2
         catch (RecognitionException re) {
 25073  2
             reportError(re);
 25074  2
             recover(input,re);
 25075  2
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 25076  2
 
 25077  2
         }
 25078  2
 
 25079  2
         finally {
 25080  2
                 // do for sure before leaving
 25081  782
         }
 25082  782
         return retval;
 25083  2
     }
 25084  2
     // $ANTLR end "blankNode"
 25085  2
 
 25086  2
 
 25087  2
     public static class anon_return extends ParserRuleReturnScope {
 25088  2
         Object tree;
 25089  2
         public Object getTree() { return tree; }
 25090  2
     };
 25091  2
 
 25092  2
 
 25093  2
     // $ANTLR start "anon"
 25094  2
     // com\\googlecode\\sparkleg\\Sparql.g:717:1: anon : '[' ']' -> ANON ;
 25095  2
     public final SparqlParser.anon_return anon() throws RecognitionException {
 25096  342
         SparqlParser.anon_return retval = new SparqlParser.anon_return();
 25097  342
         retval.start = input.LT(1);
 25098  2
 
 25099  2
 
 25100  342
         Object root_0 = null;
 25101  2
 
 25102  342
         Token char_literal685=null;
 25103  342
         Token char_literal686=null;
 25104  2
 
 25105  342
         Object char_literal685_tree=null;
 25106  342
         Object char_literal686_tree=null;
 25107  342
         RewriteRuleTokenStream stream_213=new RewriteRuleTokenStream(adaptor,"token 213");
 25108  342
         RewriteRuleTokenStream stream_214=new RewriteRuleTokenStream(adaptor,"token 214");
 25109  2
 
 25110  2
         try {
 25111  2
             // com\\googlecode\\sparkleg\\Sparql.g:718:5: ( '[' ']' -> ANON )
 25112  2
             // com\\googlecode\\sparkleg\\Sparql.g:718:7: '[' ']'
 25113  2
             {
 25114  342
             char_literal685=(Token)match(input,213,FOLLOW_213_in_anon7232);  
 25115  342
             stream_213.add(char_literal685);
 25116  2
 
 25117  2
 
 25118  342
             char_literal686=(Token)match(input,214,FOLLOW_214_in_anon7234);  
 25119  342
             stream_214.add(char_literal686);
 25120  2
 
 25121  2
 
 25122  2
             // AST REWRITE
 25123  2
             // elements: 
 25124  2
             // token labels: 
 25125  2
             // rule labels: retval
 25126  2
             // token list labels: 
 25127  2
             // rule list labels: 
 25128  2
             // wildcard labels: 
 25129  342
             retval.tree = root_0;
 25130  342
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 25131  2
 
 25132  342
             root_0 = (Object)adaptor.nil();
 25133  2
             // 718:15: -> ANON
 25134  2
             {
 25135  342
                 adaptor.addChild(root_0, 
 25136  2
                 (Object)adaptor.create(ANON, "ANON")
 25137  2
                 );
 25138  2
 
 25139  2
             }
 25140  2
 
 25141  2
 
 25142  342
             retval.tree = root_0;
 25143  2
 
 25144  2
             }
 25145  2
 
 25146  342
             retval.stop = input.LT(-1);
 25147  2
 
 25148  2
 
 25149  342
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 25150  342
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 25151  2
 
 25152  2
         }
 25153  2
         catch (RecognitionException re) {
 25154  2
             reportError(re);
 25155  2
             recover(input,re);
 25156  2
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 25157  2
 
 25158  2
         }
 25159  2
 
 25160  2
         finally {
 25161  2
                 // do for sure before leaving
 25162  342
         }
 25163  342
         return retval;
 25164  2
     }
 25165  2
     // $ANTLR end "anon"
 25166  2
 
 25167  2
     // Delegated rules
 25168  2
 
 25169  2
 
 25170  7642
     protected DFA4 dfa4 = new DFA4(this);
 25171  2
     static final String DFA4_eotS =
 25172  2
         "\10\uffff";
 25173  2
     static final String DFA4_eofS =
 25174  2
         "\10\uffff";
 25175  2
     static final String DFA4_minS =
 25176  2
         "\1\6\1\131\1\u0089\2\uffff\1\6\1\131\1\6";
 25177  2
     static final String DFA4_maxS =
 25178  2
         "\1\u00ce\1\131\1\u0089\2\uffff\1\u00ce\1\131\1\u00ce";
 25179  2
     static final String DFA4_acceptS =
 25180  2
         "\3\uffff\1\1\1\2\3\uffff";
 25181  2
     static final String DFA4_specialS =
 25182  2
         "\10\uffff}>";
 25183  7
     static final String[] DFA4_transitionS = {
 25184  2
             "\1\4\7\uffff\1\3\2\uffff\1\1\12\uffff\1\4\4\uffff\1\3\2\uffff"+
 25185  2
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\31\uffff"+
 25186  2
             "\1\4\24\uffff\1\4\10\uffff\1\4\40\uffff\1\2\14\uffff\1\3\57"+
 25187  2
             "\uffff\1\4",
 25188  2
             "\1\5",
 25189  2
             "\1\6",
 25190  2
             "",
 25191  2
             "",
 25192  2
             "\1\4\7\uffff\1\3\2\uffff\1\1\12\uffff\1\4\4\uffff\1\3\2\uffff"+
 25193  2
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\31\uffff"+
 25194  2
             "\1\4\24\uffff\1\4\10\uffff\1\4\40\uffff\1\2\14\uffff\1\3\57"+
 25195  2
             "\uffff\1\4",
 25196  2
             "\1\7",
 25197  2
             "\1\4\7\uffff\1\3\2\uffff\1\1\12\uffff\1\4\4\uffff\1\3\2\uffff"+
 25198  2
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\31\uffff"+
 25199  2
             "\1\4\24\uffff\1\4\10\uffff\1\4\40\uffff\1\2\14\uffff\1\3\57"+
 25200  2
             "\uffff\1\4"
 25201  2
     };
 25202  2
 
 25203  7
     static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
 25204  7
     static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
 25205  7
     static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
 25206  7
     static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
 25207  7
     static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
 25208  7
     static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
 25209  2
     static final short[][] DFA4_transition;
 25210  2
 
 25211  2
     static {
 25212  7
         int numStates = DFA4_transitionS.length;
 25213  7
         DFA4_transition = new short[numStates][];
 25214  47
         for (int i=0; i<numStates; i++) {
 25215  42
             DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
 25216  2
         }
 25217  2
     }
 25218  2
 
 25219  2
     class DFA4 extends DFA {
 25220  2
 
 25221  2
         public DFA4(BaseRecognizer recognizer) {
 25222  2
             this.recognizer = recognizer;
 25223  2
             this.decisionNumber = 4;
 25224  2
             this.eot = DFA4_eot;
 25225  2
             this.eof = DFA4_eof;
 25226  2
             this.min = DFA4_min;
 25227  2
             this.max = DFA4_max;
 25228  2
             this.accept = DFA4_accept;
 25229  2
             this.special = DFA4_special;
 25230  2
             this.transition = DFA4_transition;
 25231  2
         }
 25232  2
         public String getDescription() {
 25233  2
             return "98:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( ';' ( update )? )* EOF -> ^( UPDATE ( update )+ ) );";
 25234  2
         }
 25235  2
     }
 25236  2
  
 25237  2
 
 25238  7
     public static final BitSet FOLLOW_prologue_in_query251 = new BitSet(new long[]{0x0001000200004000L,0x0000000000000000L,0x0000000040000000L});
 25239  7
     public static final BitSet FOLLOW_selectQuery_in_query254 = new BitSet(new long[]{0x0000000000080000L});
 25240  7
     public static final BitSet FOLLOW_constructQuery_in_query258 = new BitSet(new long[]{0x0000000000080000L});
 25241  7
     public static final BitSet FOLLOW_describeQuery_in_query262 = new BitSet(new long[]{0x0000000000080000L});
 25242  7
     public static final BitSet FOLLOW_askQuery_in_query266 = new BitSet(new long[]{0x0000000000080000L});
 25243  7
     public static final BitSet FOLLOW_bindingsClause_in_query269 = new BitSet(new long[]{0x0000000000000000L});
 25244  7
     public static final BitSet FOLLOW_EOF_in_query271 = new BitSet(new long[]{0x0000000000000002L});
 25245  7
     public static final BitSet FOLLOW_update_in_query302 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25246  7
     public static final BitSet FOLLOW_212_in_query305 = new BitSet(new long[]{0x0100405010020040L,0x0001008000040000L,0x0000000000020000L,0x0000000000104000L});
 25247  7
     public static final BitSet FOLLOW_update_in_query307 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25248  7
     public static final BitSet FOLLOW_EOF_in_query312 = new BitSet(new long[]{0x0000000000000002L});
 25249  7
     public static final BitSet FOLLOW_baseDecl_in_prologue345 = new BitSet(new long[]{0x0000000000020002L,0x0000000000000000L,0x0000000000020000L});
 25250  7
     public static final BitSet FOLLOW_prefixDecl_in_prologue349 = new BitSet(new long[]{0x0000000000020002L,0x0000000000000000L,0x0000000000020000L});
 25251  7
     public static final BitSet FOLLOW_BASE_in_baseDecl380 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});
 25252  7
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl382 = new BitSet(new long[]{0x0000000000000002L});
 25253  7
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl408 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000200L});
 25254  7
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl410 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L});
 25255  7
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl412 = new BitSet(new long[]{0x0000000000000002L});
 25256  7
     public static final BitSet FOLLOW_selectClause_in_selectQuery439 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25257  7
     public static final BitSet FOLLOW_datasetClause_in_selectQuery441 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25258  7
     public static final BitSet FOLLOW_whereClause_in_selectQuery444 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25259  7
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery446 = new BitSet(new long[]{0x0000000000000002L});
 25260  7
     public static final BitSet FOLLOW_selectClause_in_subSelect480 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001001000L});
 25261  7
     public static final BitSet FOLLOW_whereClause_in_subSelect482 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25262  7
     public static final BitSet FOLLOW_solutionModifier_in_subSelect484 = new BitSet(new long[]{0x0000000000000002L});
 25263  7
     public static final BitSet FOLLOW_SELECT_in_selectClause520 = new BitSet(new long[]{0x0004000000008000L,0x0000000000000000L,0x0000000000800000L});
 25264  7
     public static final BitSet FOLLOW_DISTINCT_in_selectClause523 = new BitSet(new long[]{0x0000000000008000L});
 25265  7
     public static final BitSet FOLLOW_REDUCED_in_selectClause527 = new BitSet(new long[]{0x0000000000008000L});
 25266  7
     public static final BitSet FOLLOW_ASTERISK_in_selectClause531 = new BitSet(new long[]{0x0000000000000002L});
 25267  7
     public static final BitSet FOLLOW_SELECT_in_selectClause553 = new BitSet(new long[]{0x0004000000000000L,0x0000000000000000L,0x0000000000800000L,0x0000000000020600L});
 25268  7
     public static final BitSet FOLLOW_DISTINCT_in_selectClause556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020600L});
 25269  7
     public static final BitSet FOLLOW_REDUCED_in_selectClause560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020600L});
 25270  7
     public static final BitSet FOLLOW_selectVariables_in_selectClause567 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000020600L});
 25271  7
     public static final BitSet FOLLOW_var_in_selectVariables602 = new BitSet(new long[]{0x0000000000000002L});
 25272  7
     public static final BitSet FOLLOW_209_in_selectVariables619 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25273  7
     public static final BitSet FOLLOW_expression_in_selectVariables621 = new BitSet(new long[]{0x0000000000001000L});
 25274  7
     public static final BitSet FOLLOW_AS_in_selectVariables623 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25275  7
     public static final BitSet FOLLOW_var_in_selectVariables625 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25276  7
     public static final BitSet FOLLOW_210_in_selectVariables627 = new BitSet(new long[]{0x0000000000000002L});
 25277  7
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery654 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25278  7
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery656 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25279  7
     public static final BitSet FOLLOW_datasetClause_in_constructQuery658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25280  7
     public static final BitSet FOLLOW_whereClause_in_constructQuery661 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25281  7
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery663 = new BitSet(new long[]{0x0000000000000002L});
 25282  7
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery691 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000000001000L});
 25283  7
     public static final BitSet FOLLOW_datasetClause_in_constructQuery693 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000000001000L});
 25284  7
     public static final BitSet FOLLOW_WHERE_in_constructQuery696 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25285  7
     public static final BitSet FOLLOW_216_in_constructQuery698 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000004220600L});
 25286  7
     public static final BitSet FOLLOW_triplesTemplate_in_constructQuery700 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25287  7
     public static final BitSet FOLLOW_218_in_constructQuery703 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25288  7
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery705 = new BitSet(new long[]{0x0000000000000002L});
 25289  7
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery741 = new BitSet(new long[]{0x0000000000008000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25290  7
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery747 = new BitSet(new long[]{0x0000000000000000L,0x1200004002002108L,0x0000000000000300L,0x0000000001001600L});
 25291  7
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery753 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002108L,0x0000000000000000L,0x0000000001001000L});
 25292  7
     public static final BitSet FOLLOW_datasetClause_in_describeQuery756 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002108L,0x0000000000000000L,0x0000000001001000L});
 25293  7
     public static final BitSet FOLLOW_whereClause_in_describeQuery759 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25294  7
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery762 = new BitSet(new long[]{0x0000000000000002L});
 25295  7
     public static final BitSet FOLLOW_ASK_in_askQuery801 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25296  7
     public static final BitSet FOLLOW_datasetClause_in_askQuery803 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L,0x0000000000000000L,0x0000000001001000L});
 25297  7
     public static final BitSet FOLLOW_whereClause_in_askQuery806 = new BitSet(new long[]{0x0000000000000000L,0x1200004000002100L});
 25298  7
     public static final BitSet FOLLOW_solutionModifier_in_askQuery808 = new BitSet(new long[]{0x0000000000000002L});
 25299  7
     public static final BitSet FOLLOW_FROM_in_datasetClause839 = new BitSet(new long[]{0x0000000000000000L,0x0002000002000000L,0x0000000000000300L});
 25300  7
     public static final BitSet FOLLOW_NAMED_in_datasetClause841 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25301  7
     public static final BitSet FOLLOW_iriRef_in_datasetClause844 = new BitSet(new long[]{0x0000000000000002L});
 25302  7
     public static final BitSet FOLLOW_WHERE_in_whereClause872 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25303  7
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause875 = new BitSet(new long[]{0x0000000000000002L});
 25304  7
     public static final BitSet FOLLOW_groupClause_in_solutionModifier900 = new BitSet(new long[]{0x0000000000000002L,0x1200004000002000L});
 25305  7
     public static final BitSet FOLLOW_havingClause_in_solutionModifier903 = new BitSet(new long[]{0x0000000000000002L,0x1200004000000000L});
 25306  7
     public static final BitSet FOLLOW_orderClause_in_solutionModifier906 = new BitSet(new long[]{0x0000000000000002L,0x0200004000000000L});
 25307  7
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier909 = new BitSet(new long[]{0x0000000000000002L});
 25308  7
     public static final BitSet FOLLOW_GROUP_in_groupClause941 = new BitSet(new long[]{0x0000000004000000L});
 25309  7
     public static final BitSet FOLLOW_BY_in_groupClause943 = new BitSet(new long[]{0x2400030929800020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25310  7
     public static final BitSet FOLLOW_groupCondition_in_groupClause945 = new BitSet(new long[]{0x2400030929800022L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25311  7
     public static final BitSet FOLLOW_builtInCall_in_groupCondition979 = new BitSet(new long[]{0x0000000000000002L});
 25312  7
     public static final BitSet FOLLOW_functionCall_in_groupCondition995 = new BitSet(new long[]{0x0000000000000002L});
 25313  7
     public static final BitSet FOLLOW_209_in_groupCondition1011 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25314  7
     public static final BitSet FOLLOW_expression_in_groupCondition1013 = new BitSet(new long[]{0x0000000000001000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25315  7
     public static final BitSet FOLLOW_AS_in_groupCondition1016 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25316  7
     public static final BitSet FOLLOW_var_in_groupCondition1018 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25317  7
     public static final BitSet FOLLOW_210_in_groupCondition1022 = new BitSet(new long[]{0x0000000000000002L});
 25318  7
     public static final BitSet FOLLOW_var_in_groupCondition1041 = new BitSet(new long[]{0x0000000000000002L});
 25319  7
     public static final BitSet FOLLOW_HAVING_in_havingClause1070 = new BitSet(new long[]{0x2400030929800020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030043L});
 25320  7
     public static final BitSet FOLLOW_constraint_in_havingClause1072 = new BitSet(new long[]{0x2400030929800022L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030043L});
 25321  7
     public static final BitSet FOLLOW_ORDER_in_orderClause1104 = new BitSet(new long[]{0x0000000004000000L});
 25322  7
     public static final BitSet FOLLOW_BY_in_orderClause1106 = new BitSet(new long[]{0x2400830929802020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25323  7
     public static final BitSet FOLLOW_orderCondition_in_orderClause1108 = new BitSet(new long[]{0x2400830929802022L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030643L});
 25324  7
     public static final BitSet FOLLOW_ASC_in_orderCondition1135 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25325  7
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1137 = new BitSet(new long[]{0x0000000000000002L});
 25326  7
     public static final BitSet FOLLOW_DESC_in_orderCondition1155 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25327  7
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1157 = new BitSet(new long[]{0x0000000000000002L});
 25328  7
     public static final BitSet FOLLOW_constraint_in_orderCondition1175 = new BitSet(new long[]{0x0000000000000002L});
 25329  7
     public static final BitSet FOLLOW_var_in_orderCondition1191 = new BitSet(new long[]{0x0000000000000002L});
 25330  7
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1221 = new BitSet(new long[]{0x0000000000000002L,0x0200000000000000L});
 25331  7
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1223 = new BitSet(new long[]{0x0000000000000002L});
 25332  7
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1239 = new BitSet(new long[]{0x0000000000000002L,0x0000004000000000L});
 25333  7
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1241 = new BitSet(new long[]{0x0000000000000002L});
 25334  7
     public static final BitSet FOLLOW_LIMIT_in_limitClause1266 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25335  7
     public static final BitSet FOLLOW_INTEGER_in_limitClause1268 = new BitSet(new long[]{0x0000000000000002L});
 25336  7
     public static final BitSet FOLLOW_OFFSET_in_offsetClause1293 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25337  7
     public static final BitSet FOLLOW_INTEGER_in_offsetClause1295 = new BitSet(new long[]{0x0000000000000002L});
 25338  7
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause1321 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000600L});
 25339  7
     public static final BitSet FOLLOW_var_in_bindingsClause1323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000600L});
 25340  7
     public static final BitSet FOLLOW_216_in_bindingsClause1326 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004020000L});
 25341  7
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause1328 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004020000L});
 25342  7
     public static final BitSet FOLLOW_218_in_bindingsClause1331 = new BitSet(new long[]{0x0000000000000002L});
 25343  7
     public static final BitSet FOLLOW_209_in_bindingValueList1367 = new BitSet(new long[]{0x00E01C0000000000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000040008L});
 25344  7
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList1369 = new BitSet(new long[]{0x00E01C0000000000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000040008L});
 25345  7
     public static final BitSet FOLLOW_210_in_bindingValueList1372 = new BitSet(new long[]{0x0000000000000002L});
 25346  7
     public static final BitSet FOLLOW_iriRef_in_bindingValue1403 = new BitSet(new long[]{0x0000000000000002L});
 25347  7
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue1407 = new BitSet(new long[]{0x0000000000000002L});
 25348  7
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue1411 = new BitSet(new long[]{0x0000000000000002L});
 25349  7
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue1415 = new BitSet(new long[]{0x0000000000000002L});
 25350  7
     public static final BitSet FOLLOW_UNDEF_in_bindingValue1419 = new BitSet(new long[]{0x0000000000000002L});
 25351  7
     public static final BitSet FOLLOW_prologue_in_update1440 = new BitSet(new long[]{0x0100405010000040L,0x0001008000040000L,0x0000000000000000L,0x0000000000004000L});
 25352  7
     public static final BitSet FOLLOW_load_in_update1443 = new BitSet(new long[]{0x0000000000000002L});
 25353  7
     public static final BitSet FOLLOW_clear_in_update1447 = new BitSet(new long[]{0x0000000000000002L});
 25354  7
     public static final BitSet FOLLOW_drop_in_update1451 = new BitSet(new long[]{0x0000000000000002L});
 25355  7
     public static final BitSet FOLLOW_add_in_update1455 = new BitSet(new long[]{0x0000000000000002L});
 25356  7
     public static final BitSet FOLLOW_move_in_update1459 = new BitSet(new long[]{0x0000000000000002L});
 25357  7
     public static final BitSet FOLLOW_copy_in_update1463 = new BitSet(new long[]{0x0000000000000002L});
 25358  7
     public static final BitSet FOLLOW_create_in_update1467 = new BitSet(new long[]{0x0000000000000002L});
 25359  7
     public static final BitSet FOLLOW_insert_in_update1471 = new BitSet(new long[]{0x0000000000000002L});
 25360  7
     public static final BitSet FOLLOW_delete_in_update1475 = new BitSet(new long[]{0x0000000000000002L});
 25361  7
     public static final BitSet FOLLOW_modify_in_update1479 = new BitSet(new long[]{0x0000000000000002L});
 25362  7
     public static final BitSet FOLLOW_LOAD_in_load1542 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000010000000300L});
 25363  7
     public static final BitSet FOLLOW_SILENT_in_load1544 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25364  7
     public static final BitSet FOLLOW_iriRef_in_load1547 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L});
 25365  7
     public static final BitSet FOLLOW_INTO_in_load1550 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
 25366  7
     public static final BitSet FOLLOW_graphRef_in_load1552 = new BitSet(new long[]{0x0000000000000002L});
 25367  7
     public static final BitSet FOLLOW_CLEAR_in_clear1589 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L,0x0000010000000000L});
 25368  7
     public static final BitSet FOLLOW_SILENT_in_clear1592 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L});
 25369  7
     public static final BitSet FOLLOW_graphRefAll_in_clear1595 = new BitSet(new long[]{0x0000000000000002L});
 25370  7
     public static final BitSet FOLLOW_DROP_in_drop1627 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L,0x0000010000000000L});
 25371  7
     public static final BitSet FOLLOW_SILENT_in_drop1629 = new BitSet(new long[]{0x0000200000000080L,0x0002000000000020L});
 25372  7
     public static final BitSet FOLLOW_graphRefAll_in_drop1632 = new BitSet(new long[]{0x0000000000000002L});
 25373  7
     public static final BitSet FOLLOW_CREATE_in_create1661 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L,0x0000010000000000L});
 25374  7
     public static final BitSet FOLLOW_SILENT_in_create1663 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
 25375  7
     public static final BitSet FOLLOW_graphRef_in_create1666 = new BitSet(new long[]{0x0000000000000002L});
 25376  7
     public static final BitSet FOLLOW_ADD_in_add1698 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000010000000300L});
 25377  7
     public static final BitSet FOLLOW_SILENT_in_add1700 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25378  7
     public static final BitSet FOLLOW_graphOrDefault_in_add1705 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
 25379  7
     public static final BitSet FOLLOW_TO_in_add1707 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25380  7
     public static final BitSet FOLLOW_graphOrDefault_in_add1711 = new BitSet(new long[]{0x0000000000000002L});
 25381  7
     public static final BitSet FOLLOW_MOVE_in_move1747 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000010000000300L});
 25382  7
     public static final BitSet FOLLOW_SILENT_in_move1749 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25383  7
     public static final BitSet FOLLOW_graphOrDefault_in_move1754 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
 25384  7
     public static final BitSet FOLLOW_TO_in_move1756 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25385  7
     public static final BitSet FOLLOW_graphOrDefault_in_move1760 = new BitSet(new long[]{0x0000000000000002L});
 25386  7
     public static final BitSet FOLLOW_COPY_in_copy1796 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000010000000300L});
 25387  7
     public static final BitSet FOLLOW_SILENT_in_copy1798 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25388  7
     public static final BitSet FOLLOW_graphOrDefault_in_copy1803 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0400000000000000L});
 25389  7
     public static final BitSet FOLLOW_TO_in_copy1805 = new BitSet(new long[]{0x0000200000000000L,0x0000000002000020L,0x0000000000000300L});
 25390  7
     public static final BitSet FOLLOW_graphOrDefault_in_copy1809 = new BitSet(new long[]{0x0000000000000002L});
 25391  7
     public static final BitSet FOLLOW_INSERT_in_insert1841 = new BitSet(new long[]{0x0000008000000000L});
 25392  7
     public static final BitSet FOLLOW_DATA_in_insert1843 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25393  7
     public static final BitSet FOLLOW_quadPattern_in_insert1845 = new BitSet(new long[]{0x0000000000000002L});
 25394  7
     public static final BitSet FOLLOW_DELETE_in_delete1879 = new BitSet(new long[]{0x0000008000000000L});
 25395  7
     public static final BitSet FOLLOW_deleteData_in_delete1881 = new BitSet(new long[]{0x0000000000000002L});
 25396  7
     public static final BitSet FOLLOW_DELETE_in_delete1897 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001000L});
 25397  7
     public static final BitSet FOLLOW_deleteWhere_in_delete1899 = new BitSet(new long[]{0x0000000000000002L});
 25398  7
     public static final BitSet FOLLOW_DATA_in_deleteData1924 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25399  7
     public static final BitSet FOLLOW_quadPattern_in_deleteData1926 = new BitSet(new long[]{0x0000000000000002L});
 25400  7
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1953 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25401  7
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1955 = new BitSet(new long[]{0x0000000000000002L});
 25402  7
     public static final BitSet FOLLOW_WITH_in_modify1987 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25403  7
     public static final BitSet FOLLOW_iriRef_in_modify1989 = new BitSet(new long[]{0x0000400000000000L,0x0000000000040000L});
 25404  7
     public static final BitSet FOLLOW_deleteClause_in_modify1994 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L,0x0000000000000000L,0x0000000000001080L});
 25405  7
     public static final BitSet FOLLOW_insertClause_in_modify1996 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001080L});
 25406  7
     public static final BitSet FOLLOW_insertClause_in_modify2001 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001080L});
 25407  7
     public static final BitSet FOLLOW_usingClause_in_modify2004 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000001080L});
 25408  7
     public static final BitSet FOLLOW_WHERE_in_modify2007 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25409  7
     public static final BitSet FOLLOW_groupGraphPattern_in_modify2009 = new BitSet(new long[]{0x0000000000000002L});
 25410  7
     public static final BitSet FOLLOW_DELETE_in_deleteClause2056 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25411  7
     public static final BitSet FOLLOW_quadPattern_in_deleteClause2058 = new BitSet(new long[]{0x0000000000000002L});
 25412  7
     public static final BitSet FOLLOW_INSERT_in_insertClause2089 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25413  7
     public static final BitSet FOLLOW_quadPattern_in_insertClause2091 = new BitSet(new long[]{0x0000000000000002L});
 25414  7
     public static final BitSet FOLLOW_USING_in_usingClause2116 = new BitSet(new long[]{0x0000000000000000L,0x0002000002000000L,0x0000000000000300L});
 25415  7
     public static final BitSet FOLLOW_NAMED_in_usingClause2118 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25416  7
     public static final BitSet FOLLOW_iriRef_in_usingClause2121 = new BitSet(new long[]{0x0000000000000002L});
 25417  7
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault2152 = new BitSet(new long[]{0x0000000000000002L});
 25418  7
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault2161 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25419  7
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault2164 = new BitSet(new long[]{0x0000000000000002L});
 25420  7
     public static final BitSet FOLLOW_GRAPH_in_graphRef2191 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25421  7
     public static final BitSet FOLLOW_iriRef_in_graphRef2193 = new BitSet(new long[]{0x0000000000000002L});
 25422  7
     public static final BitSet FOLLOW_graphRef_in_graphRefAll2210 = new BitSet(new long[]{0x0000000000000002L});
 25423  7
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll2214 = new BitSet(new long[]{0x0000000000000002L});
 25424  7
     public static final BitSet FOLLOW_NAMED_in_graphRefAll2218 = new BitSet(new long[]{0x0000000000000002L});
 25425  7
     public static final BitSet FOLLOW_ALL_in_graphRefAll2222 = new BitSet(new long[]{0x0000000000000002L});
 25426  7
     public static final BitSet FOLLOW_216_in_quadPattern2239 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380021L,0x8003C00000000300L,0x0000000004220600L});
 25427  7
     public static final BitSet FOLLOW_quads_in_quadPattern2241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25428  7
     public static final BitSet FOLLOW_218_in_quadPattern2243 = new BitSet(new long[]{0x0000000000000002L});
 25429  7
     public static final BitSet FOLLOW_triplesTemplate_in_quads2268 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
 25430  7
     public static final BitSet FOLLOW_quadsDetails_in_quads2271 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L});
 25431  7
     public static final BitSet FOLLOW_quadsNotTriples_in_quadsDetails2303 = new BitSet(new long[]{0x00F01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25432  7
     public static final BitSet FOLLOW_DOT_in_quadsDetails2305 = new BitSet(new long[]{0x00E01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25433  7
     public static final BitSet FOLLOW_triplesTemplate_in_quadsDetails2308 = new BitSet(new long[]{0x0000000000000002L});
 25434  7
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples2338 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25435  7
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples2340 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25436  7
     public static final BitSet FOLLOW_216_in_quadsNotTriples2342 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000004220600L});
 25437  7
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples2344 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25438  7
     public static final BitSet FOLLOW_218_in_quadsNotTriples2347 = new BitSet(new long[]{0x0000000000000002L});
 25439  7
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2379 = new BitSet(new long[]{0x0010000000000002L});
 25440  7
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2382 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25441  7
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2384 = new BitSet(new long[]{0x0010000000000002L});
 25442  7
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2388 = new BitSet(new long[]{0x0000000000000002L});
 25443  7
     public static final BitSet FOLLOW_216_in_groupGraphPattern2420 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
 25444  7
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern2422 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25445  7
     public static final BitSet FOLLOW_218_in_groupGraphPattern2424 = new BitSet(new long[]{0x0000000000000002L});
 25446  7
     public static final BitSet FOLLOW_216_in_groupGraphPattern2440 = new BitSet(new long[]{0x00E01C0000440000L,0x0400100002380023L,0x8003C00200000300L,0x0000000001220600L});
 25447  7
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern2442 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25448  7
     public static final BitSet FOLLOW_218_in_groupGraphPattern2444 = new BitSet(new long[]{0x0000000000000002L});
 25449  7
     public static final BitSet FOLLOW_216_in_groupGraphPattern2460 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25450  7
     public static final BitSet FOLLOW_218_in_groupGraphPattern2462 = new BitSet(new long[]{0x0000000000000002L});
 25451  7
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub2491 = new BitSet(new long[]{0x0000000000040002L,0x0400100000000022L,0x0000000200000000L,0x0000000001000000L});
 25452  7
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2493 = new BitSet(new long[]{0x0000000000040002L,0x0400100000000022L,0x0000000200000000L,0x0000000001000000L});
 25453  7
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2509 = new BitSet(new long[]{0x0000000000040002L,0x0400100000000022L,0x0000000200000000L,0x0000000001000000L});
 25454  7
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2532 = new BitSet(new long[]{0x00F01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25455  7
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail2534 = new BitSet(new long[]{0x00E01C0000400002L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25456  7
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2537 = new BitSet(new long[]{0x0000000000000002L});
 25457  7
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2562 = new BitSet(new long[]{0x0010000000000002L});
 25458  7
     public static final BitSet FOLLOW_DOT_in_triplesBlock2565 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25459  7
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2567 = new BitSet(new long[]{0x0010000000000002L});
 25460  7
     public static final BitSet FOLLOW_DOT_in_triplesBlock2571 = new BitSet(new long[]{0x0000000000000002L});
 25461  7
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2594 = new BitSet(new long[]{0x0000000000000002L});
 25462  7
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2598 = new BitSet(new long[]{0x0000000000000002L});
 25463  7
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples2602 = new BitSet(new long[]{0x0000000000000002L});
 25464  7
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples2606 = new BitSet(new long[]{0x0000000000000002L});
 25465  7
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2610 = new BitSet(new long[]{0x0000000000000002L});
 25466  7
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples2614 = new BitSet(new long[]{0x0000000000000002L});
 25467  7
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples2618 = new BitSet(new long[]{0x0000000000000002L});
 25468  7
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern2635 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25469  7
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern2637 = new BitSet(new long[]{0x0000000000000002L});
 25470  7
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern2662 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25471  7
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern2664 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25472  7
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern2666 = new BitSet(new long[]{0x0000000000000002L});
 25473  7
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern2693 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000010000000300L,0x0000000000000600L});
 25474  7
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern2695 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L,0x0000000000000600L});
 25475  7
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern2698 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25476  7
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern2700 = new BitSet(new long[]{0x0000000000000002L});
 25477  7
     public static final BitSet FOLLOW_BIND_in_bind2734 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25478  7
     public static final BitSet FOLLOW_209_in_bind2736 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25479  7
     public static final BitSet FOLLOW_expression_in_bind2738 = new BitSet(new long[]{0x0000000000001000L});
 25480  7
     public static final BitSet FOLLOW_AS_in_bind2740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25481  7
     public static final BitSet FOLLOW_var_in_bind2742 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25482  7
     public static final BitSet FOLLOW_210_in_bind2744 = new BitSet(new long[]{0x0000000000000002L});
 25483  7
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2781 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25484  7
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern2783 = new BitSet(new long[]{0x0000000000000002L});
 25485  7
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2811 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
 25486  7
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern2819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25487  7
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2823 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000010L});
 25488  7
     public static final BitSet FOLLOW_FILTER_in_filter2855 = new BitSet(new long[]{0x2400030929800020L,0x0090A20BFB018004L,0x029C3E742F200300L,0x0000000000030043L});
 25489  7
     public static final BitSet FOLLOW_constraint_in_filter2857 = new BitSet(new long[]{0x0000000000000002L});
 25490  7
     public static final BitSet FOLLOW_brackettedExpression_in_constraint2882 = new BitSet(new long[]{0x0000000000000002L});
 25491  7
     public static final BitSet FOLLOW_builtInCall_in_constraint2890 = new BitSet(new long[]{0x0000000000000002L});
 25492  7
     public static final BitSet FOLLOW_functionCall_in_constraint2898 = new BitSet(new long[]{0x0000000000000002L});
 25493  7
     public static final BitSet FOLLOW_iriRef_in_functionCall2915 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25494  7
     public static final BitSet FOLLOW_argList_in_functionCall2917 = new BitSet(new long[]{0x0000000000000002L});
 25495  7
     public static final BitSet FOLLOW_nil_in_argList2948 = new BitSet(new long[]{0x0000000000000002L});
 25496  7
     public static final BitSet FOLLOW_209_in_argList2960 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25497  7
     public static final BitSet FOLLOW_DISTINCT_in_argList2962 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25498  7
     public static final BitSet FOLLOW_expression_in_argList2965 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25499  7
     public static final BitSet FOLLOW_211_in_argList2968 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25500  7
     public static final BitSet FOLLOW_expression_in_argList2970 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25501  7
     public static final BitSet FOLLOW_210_in_argList2974 = new BitSet(new long[]{0x0000000000000002L});
 25502  7
     public static final BitSet FOLLOW_nil_in_expressionList3000 = new BitSet(new long[]{0x0000000000000002L});
 25503  7
     public static final BitSet FOLLOW_209_in_expressionList3004 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25504  7
     public static final BitSet FOLLOW_expression_in_expressionList3006 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25505  7
     public static final BitSet FOLLOW_211_in_expressionList3009 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25506  7
     public static final BitSet FOLLOW_expression_in_expressionList3011 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25507  7
     public static final BitSet FOLLOW_210_in_expressionList3015 = new BitSet(new long[]{0x0000000000000002L});
 25508  7
     public static final BitSet FOLLOW_216_in_constructTemplate3046 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000004220600L});
 25509  7
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate3048 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25510  7
     public static final BitSet FOLLOW_218_in_constructTemplate3051 = new BitSet(new long[]{0x0000000000000002L});
 25511  7
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples3077 = new BitSet(new long[]{0x0010000000000002L});
 25512  7
     public static final BitSet FOLLOW_DOT_in_constructTriples3080 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25513  7
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples3082 = new BitSet(new long[]{0x0010000000000002L});
 25514  7
     public static final BitSet FOLLOW_DOT_in_constructTriples3086 = new BitSet(new long[]{0x0000000000000002L});
 25515  7
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject3109 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25516  7
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3111 = new BitSet(new long[]{0x0000000000000002L});
 25517  7
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject3135 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25518  7
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3137 = new BitSet(new long[]{0x0000000000000002L});
 25519  7
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3167 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25520  7
     public static final BitSet FOLLOW_212_in_propertyListNotEmpty3170 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000120600L});
 25521  7
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3172 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25522  7
     public static final BitSet FOLLOW_graphNode_in_objectList3198 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25523  7
     public static final BitSet FOLLOW_211_in_objectList3201 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25524  7
     public static final BitSet FOLLOW_graphNode_in_objectList3203 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25525  7
     public static final BitSet FOLLOW_varOrIRIref_in_verb3231 = new BitSet(new long[]{0x0000000000000002L});
 25526  7
     public static final BitSet FOLLOW_A_in_verb3239 = new BitSet(new long[]{0x0000000000000002L});
 25527  7
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath3256 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25528  7
     public static final BitSet FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3258 = new BitSet(new long[]{0x0000000000000002L});
 25529  7
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath3280 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25530  7
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3282 = new BitSet(new long[]{0x0000000000000002L});
 25531  7
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3314 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25532  7
     public static final BitSet FOLLOW_212_in_propertyListNotEmptyPath3317 = new BitSet(new long[]{0x0000000000000012L,0x0004000002800000L,0x0000000000000300L,0x0000000000120600L});
 25533  7
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3319 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000100000L});
 25534  7
     public static final BitSet FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3346 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25535  7
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails3348 = new BitSet(new long[]{0x0000000000000002L});
 25536  7
     public static final BitSet FOLLOW_verbPath_in_verbSimpleOrPath3378 = new BitSet(new long[]{0x0000000000000002L});
 25537  7
     public static final BitSet FOLLOW_verbSimple_in_verbSimpleOrPath3386 = new BitSet(new long[]{0x0000000000000002L});
 25538  7
     public static final BitSet FOLLOW_path_in_verbPath3405 = new BitSet(new long[]{0x0000000000000002L});
 25539  7
     public static final BitSet FOLLOW_var_in_verbSimple3426 = new BitSet(new long[]{0x0000000000000002L});
 25540  7
     public static final BitSet FOLLOW_pathSequence_in_path3448 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000002000000L});
 25541  7
     public static final BitSet FOLLOW_217_in_path3451 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020000L});
 25542  7
     public static final BitSet FOLLOW_pathSequence_in_path3453 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000002000000L});
 25543  7
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3482 = new BitSet(new long[]{0x0008000000000002L});
 25544  7
     public static final BitSet FOLLOW_DIVIDE_in_pathSequence3485 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020000L});
 25545  7
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3487 = new BitSet(new long[]{0x0008000000000002L});
 25546  7
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse3518 = new BitSet(new long[]{0x0000000000000010L,0x0004000002000000L,0x0000000000000300L,0x0000000000020000L});
 25547  7
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse3522 = new BitSet(new long[]{0x0000000000000002L});
 25548  7
     public static final BitSet FOLLOW_pathPrimary_in_pathElt3562 = new BitSet(new long[]{0x0000000000008002L,0x0000000000000000L,0x0000000000100040L,0x0000000001000000L});
 25549  7
     public static final BitSet FOLLOW_pathMod_in_pathElt3564 = new BitSet(new long[]{0x0000000000000002L});
 25550  7
     public static final BitSet FOLLOW_ASTERISK_in_pathMod3582 = new BitSet(new long[]{0x0000000000000002L});
 25551  7
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod3596 = new BitSet(new long[]{0x0000000000000002L});
 25552  7
     public static final BitSet FOLLOW_PLUS_in_pathMod3611 = new BitSet(new long[]{0x0000000000000002L});
 25553  7
     public static final BitSet FOLLOW_216_in_pathMod3626 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25554  7
     public static final BitSet FOLLOW_INTEGER_in_pathMod3630 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25555  7
     public static final BitSet FOLLOW_218_in_pathMod3632 = new BitSet(new long[]{0x0000000000000002L});
 25556  7
     public static final BitSet FOLLOW_216_in_pathMod3647 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25557  7
     public static final BitSet FOLLOW_INTEGER_in_pathMod3651 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25558  7
     public static final BitSet FOLLOW_211_in_pathMod3655 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25559  7
     public static final BitSet FOLLOW_218_in_pathMod3657 = new BitSet(new long[]{0x0000000000000002L});
 25560  7
     public static final BitSet FOLLOW_216_in_pathMod3675 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25561  7
     public static final BitSet FOLLOW_INTEGER_in_pathMod3679 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25562  7
     public static final BitSet FOLLOW_211_in_pathMod3681 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25563  7
     public static final BitSet FOLLOW_INTEGER_in_pathMod3685 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25564  7
     public static final BitSet FOLLOW_218_in_pathMod3687 = new BitSet(new long[]{0x0000000000000002L});
 25565  7
     public static final BitSet FOLLOW_216_in_pathMod3706 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25566  7
     public static final BitSet FOLLOW_211_in_pathMod3710 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25567  7
     public static final BitSet FOLLOW_INTEGER_in_pathMod3714 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000004000000L});
 25568  7
     public static final BitSet FOLLOW_218_in_pathMod3716 = new BitSet(new long[]{0x0000000000000002L});
 25569  7
     public static final BitSet FOLLOW_iriRef_in_pathPrimary3743 = new BitSet(new long[]{0x0000000000000002L});
 25570  7
     public static final BitSet FOLLOW_A_in_pathPrimary3759 = new BitSet(new long[]{0x0000000000000002L});
 25571  7
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary3775 = new BitSet(new long[]{0x0000000000000010L,0x0000000002800000L,0x0000000000000300L,0x0000000000020000L});
 25572  7
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary3777 = new BitSet(new long[]{0x0000000000000002L});
 25573  7
     public static final BitSet FOLLOW_209_in_pathPrimary3793 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020000L});
 25574  7
     public static final BitSet FOLLOW_path_in_pathPrimary3795 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25575  7
     public static final BitSet FOLLOW_210_in_pathPrimary3797 = new BitSet(new long[]{0x0000000000000002L});
 25576  7
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3822 = new BitSet(new long[]{0x0000000000000002L});
 25577  7
     public static final BitSet FOLLOW_209_in_pathNegatedPropertySet3838 = new BitSet(new long[]{0x0000000000000010L,0x0000000002800000L,0x0000000000000300L,0x0000000000040000L});
 25578  7
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3841 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000002040000L});
 25579  7
     public static final BitSet FOLLOW_217_in_pathNegatedPropertySet3844 = new BitSet(new long[]{0x0000000000000010L,0x0000000002800000L,0x0000000000000300L});
 25580  7
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3846 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000002040000L});
 25581  7
     public static final BitSet FOLLOW_210_in_pathNegatedPropertySet3852 = new BitSet(new long[]{0x0000000000000002L});
 25582  7
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet3881 = new BitSet(new long[]{0x0000000000000010L,0x0000000002000000L,0x0000000000000300L});
 25583  7
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet3885 = new BitSet(new long[]{0x0000000000000002L});
 25584  7
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet3889 = new BitSet(new long[]{0x0000000000000002L});
 25585  7
     public static final BitSet FOLLOW_209_in_triplesNode3908 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000220600L});
 25586  7
     public static final BitSet FOLLOW_graphNode_in_triplesNode3910 = new BitSet(new long[]{0x00E01C0000400000L,0x0000000002380001L,0x8003C00000000300L,0x0000000000260600L});
 25587  7
     public static final BitSet FOLLOW_210_in_triplesNode3913 = new BitSet(new long[]{0x0000000000000002L});
 25588  7
     public static final BitSet FOLLOW_213_in_triplesNode3930 = new BitSet(new long[]{0x0000000000000010L,0x0004000002800000L,0x0000000000000300L,0x0000000000020600L});
 25589  7
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode3932 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
 25590  7
     public static final BitSet FOLLOW_214_in_triplesNode3934 = new BitSet(new long[]{0x0000000000000002L});
 25591  7
     public static final BitSet FOLLOW_varOrTerm_in_graphNode3959 = new BitSet(new long[]{0x0000000000000002L});
 25592  7
     public static final BitSet FOLLOW_triplesNode_in_graphNode3963 = new BitSet(new long[]{0x0000000000000002L});
 25593  7
     public static final BitSet FOLLOW_var_in_varOrTerm3980 = new BitSet(new long[]{0x0000000000000002L});
 25594  7
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm3988 = new BitSet(new long[]{0x0000000000000002L});
 25595  7
     public static final BitSet FOLLOW_var_in_varOrIRIref4005 = new BitSet(new long[]{0x0000000000000002L});
 25596  7
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref4009 = new BitSet(new long[]{0x0000000000000002L});
 25597  7
     public static final BitSet FOLLOW_iriRef_in_graphTerm4047 = new BitSet(new long[]{0x0000000000000002L});
 25598  7
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm4055 = new BitSet(new long[]{0x0000000000000002L});
 25599  7
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm4063 = new BitSet(new long[]{0x0000000000000002L});
 25600  7
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm4071 = new BitSet(new long[]{0x0000000000000002L});
 25601  7
     public static final BitSet FOLLOW_blankNode_in_graphTerm4079 = new BitSet(new long[]{0x0000000000000002L});
 25602  7
     public static final BitSet FOLLOW_nil_in_graphTerm4087 = new BitSet(new long[]{0x0000000000000002L});
 25603  7
     public static final BitSet FOLLOW_209_in_nil4108 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25604  7
     public static final BitSet FOLLOW_210_in_nil4110 = new BitSet(new long[]{0x0000000000000002L});
 25605  7
     public static final BitSet FOLLOW_conditionalOrExpression_in_expression4131 = new BitSet(new long[]{0x0000000000000002L});
 25606  7
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression4151 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25607  7
     public static final BitSet FOLLOW_OR_in_conditionalOrExpression4160 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25608  7
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression4164 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25609  7
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression4198 = new BitSet(new long[]{0x0000000000000102L});
 25610  7
     public static final BitSet FOLLOW_AND_in_conditionalAndExpression4207 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25611  7
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression4211 = new BitSet(new long[]{0x0000000000000102L});
 25612  7
     public static final BitSet FOLLOW_relationalExpression_in_valueLogical4242 = new BitSet(new long[]{0x0000000000000002L});
 25613  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4262 = new BitSet(new long[]{0x1000000000000002L,0x00300030000200C0L});
 25614  7
     public static final BitSet FOLLOW_EQUAL_in_relationalExpression4272 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25615  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4276 = new BitSet(new long[]{0x0000000000000002L});
 25616  7
     public static final BitSet FOLLOW_NOT_EQUAL_in_relationalExpression4333 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25617  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4337 = new BitSet(new long[]{0x0000000000000002L});
 25618  7
     public static final BitSet FOLLOW_LESS_in_relationalExpression4392 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25619  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4396 = new BitSet(new long[]{0x0000000000000002L});
 25620  7
     public static final BitSet FOLLOW_GREATER_in_relationalExpression4451 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25621  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4455 = new BitSet(new long[]{0x0000000000000002L});
 25622  7
     public static final BitSet FOLLOW_LESS_EQUAL_in_relationalExpression4509 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25623  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4513 = new BitSet(new long[]{0x0000000000000002L});
 25624  7
     public static final BitSet FOLLOW_GREATER_EQUAL_in_relationalExpression4567 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25625  7
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4571 = new BitSet(new long[]{0x0000000000000002L});
 25626  7
     public static final BitSet FOLLOW_IN_in_relationalExpression4627 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25627  7
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4631 = new BitSet(new long[]{0x0000000000000002L});
 25628  7
     public static final BitSet FOLLOW_NOT_in_relationalExpression4685 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
 25629  7
     public static final BitSet FOLLOW_IN_in_relationalExpression4687 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25630  7
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4691 = new BitSet(new long[]{0x0000000000000002L});
 25631  7
     public static final BitSet FOLLOW_additiveExpression_in_numericExpression4725 = new BitSet(new long[]{0x0000000000000002L});
 25632  7
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4745 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25633  7
     public static final BitSet FOLLOW_additiveOperator_in_additiveExpression4755 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25634  7
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4759 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25635  7
     public static final BitSet FOLLOW_numericLiteralPositive_in_additiveExpression4826 = new BitSet(new long[]{0x00C8180000008002L,0x0000080000300000L,0x0000000000000040L});
 25636  7
     public static final BitSet FOLLOW_numericLiteralNegative_in_additiveExpression4844 = new BitSet(new long[]{0x00C8180000008002L,0x0000080000300000L,0x0000000000000040L});
 25637  7
     public static final BitSet FOLLOW_ASTERISK_in_additiveExpression4908 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25638  7
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4912 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25639  7
     public static final BitSet FOLLOW_DIVIDE_in_additiveExpression4978 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25640  7
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4982 = new BitSet(new long[]{0x00C0180000000002L,0x0000080000300000L,0x0000000000000040L});
 25641  7
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5048 = new BitSet(new long[]{0x0008000000008002L});
 25642  7
     public static final BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression5057 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25643  7
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression5061 = new BitSet(new long[]{0x0008000000008002L});
 25644  7
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression5116 = new BitSet(new long[]{0x24E01F2929810020L,0x0090A70BFB398405L,0x839FFE743F200300L,0x0000000000030643L});
 25645  7
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5118 = new BitSet(new long[]{0x0000000000000002L});
 25646  7
     public static final BitSet FOLLOW_PLUS_in_unaryExpression5136 = new BitSet(new long[]{0x24E01F2929810020L,0x0090A70BFB398405L,0x839FFE743F200300L,0x0000000000030643L});
 25647  7
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5138 = new BitSet(new long[]{0x0000000000000002L});
 25648  7
     public static final BitSet FOLLOW_MINUS_in_unaryExpression5156 = new BitSet(new long[]{0x24E01F2929810020L,0x0090A70BFB398405L,0x839FFE743F200300L,0x0000000000030643L});
 25649  7
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5158 = new BitSet(new long[]{0x0000000000000002L});
 25650  7
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression5176 = new BitSet(new long[]{0x0000000000000002L});
 25651  7
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression5201 = new BitSet(new long[]{0x0000000000000002L});
 25652  7
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression5205 = new BitSet(new long[]{0x0000000000000002L});
 25653  7
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression5209 = new BitSet(new long[]{0x0000000000000002L});
 25654  7
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression5213 = new BitSet(new long[]{0x0000000000000002L});
 25655  7
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression5217 = new BitSet(new long[]{0x0000000000000002L});
 25656  7
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression5221 = new BitSet(new long[]{0x0000000000000002L});
 25657  7
     public static final BitSet FOLLOW_var_in_primaryExpression5225 = new BitSet(new long[]{0x0000000000000002L});
 25658  7
     public static final BitSet FOLLOW_aggregate_in_primaryExpression5229 = new BitSet(new long[]{0x0000000000000002L});
 25659  7
     public static final BitSet FOLLOW_209_in_brackettedExpression5246 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25660  7
     public static final BitSet FOLLOW_expression_in_brackettedExpression5248 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25661  7
     public static final BitSet FOLLOW_210_in_brackettedExpression5250 = new BitSet(new long[]{0x0000000000000002L});
 25662  7
     public static final BitSet FOLLOW_STR_in_builtInCall5275 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25663  7
     public static final BitSet FOLLOW_209_in_builtInCall5277 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25664  7
     public static final BitSet FOLLOW_expression_in_builtInCall5279 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25665  7
     public static final BitSet FOLLOW_210_in_builtInCall5281 = new BitSet(new long[]{0x0000000000000002L});
 25666  7
     public static final BitSet FOLLOW_LANG_in_builtInCall5297 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25667  7
     public static final BitSet FOLLOW_209_in_builtInCall5299 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25668  7
     public static final BitSet FOLLOW_expression_in_builtInCall5301 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25669  7
     public static final BitSet FOLLOW_210_in_builtInCall5303 = new BitSet(new long[]{0x0000000000000002L});
 25670  7
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall5319 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25671  7
     public static final BitSet FOLLOW_209_in_builtInCall5321 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25672  7
     public static final BitSet FOLLOW_expression_in_builtInCall5323 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25673  7
     public static final BitSet FOLLOW_211_in_builtInCall5325 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25674  7
     public static final BitSet FOLLOW_expression_in_builtInCall5327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25675  7
     public static final BitSet FOLLOW_210_in_builtInCall5329 = new BitSet(new long[]{0x0000000000000002L});
 25676  7
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall5346 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25677  7
     public static final BitSet FOLLOW_209_in_builtInCall5348 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25678  7
     public static final BitSet FOLLOW_expression_in_builtInCall5350 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25679  7
     public static final BitSet FOLLOW_210_in_builtInCall5352 = new BitSet(new long[]{0x0000000000000002L});
 25680  7
     public static final BitSet FOLLOW_BOUND_in_builtInCall5368 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25681  7
     public static final BitSet FOLLOW_209_in_builtInCall5370 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000600L});
 25682  7
     public static final BitSet FOLLOW_var_in_builtInCall5372 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25683  7
     public static final BitSet FOLLOW_210_in_builtInCall5374 = new BitSet(new long[]{0x0000000000000002L});
 25684  7
     public static final BitSet FOLLOW_IRI_in_builtInCall5390 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25685  7
     public static final BitSet FOLLOW_209_in_builtInCall5392 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25686  7
     public static final BitSet FOLLOW_expression_in_builtInCall5394 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25687  7
     public static final BitSet FOLLOW_210_in_builtInCall5396 = new BitSet(new long[]{0x0000000000000002L});
 25688  7
     public static final BitSet FOLLOW_URI_in_builtInCall5412 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25689  7
     public static final BitSet FOLLOW_209_in_builtInCall5414 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25690  7
     public static final BitSet FOLLOW_expression_in_builtInCall5416 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25691  7
     public static final BitSet FOLLOW_210_in_builtInCall5418 = new BitSet(new long[]{0x0000000000000002L});
 25692  7
     public static final BitSet FOLLOW_BNODE_in_builtInCall5434 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25693  7
     public static final BitSet FOLLOW_209_in_builtInCall5437 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25694  7
     public static final BitSet FOLLOW_expression_in_builtInCall5439 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25695  7
     public static final BitSet FOLLOW_210_in_builtInCall5441 = new BitSet(new long[]{0x0000000000000002L});
 25696  5
     public static final BitSet FOLLOW_BNODE_in_builtInCall5458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25697  5
     public static final BitSet FOLLOW_nil_in_builtInCall5460 = new BitSet(new long[]{0x0000000000000002L});
 25698  5
     public static final BitSet FOLLOW_RAND_in_builtInCall5472 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25699  5
     public static final BitSet FOLLOW_nil_in_builtInCall5474 = new BitSet(new long[]{0x0000000000000002L});
 25700  5
     public static final BitSet FOLLOW_ABS_in_builtInCall5486 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25701  5
     public static final BitSet FOLLOW_209_in_builtInCall5488 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25702  5
     public static final BitSet FOLLOW_expression_in_builtInCall5490 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25703  5
     public static final BitSet FOLLOW_210_in_builtInCall5492 = new BitSet(new long[]{0x0000000000000002L});
 25704  5
     public static final BitSet FOLLOW_CEIL_in_builtInCall5508 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25705  5
     public static final BitSet FOLLOW_209_in_builtInCall5510 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25706  5
     public static final BitSet FOLLOW_expression_in_builtInCall5512 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25707  5
     public static final BitSet FOLLOW_210_in_builtInCall5514 = new BitSet(new long[]{0x0000000000000002L});
 25708  5
     public static final BitSet FOLLOW_FLOOR_in_builtInCall5530 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25709  5
     public static final BitSet FOLLOW_209_in_builtInCall5532 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25710  5
     public static final BitSet FOLLOW_expression_in_builtInCall5534 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25711  5
     public static final BitSet FOLLOW_210_in_builtInCall5536 = new BitSet(new long[]{0x0000000000000002L});
 25712  5
     public static final BitSet FOLLOW_ROUND_in_builtInCall5552 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25713  5
     public static final BitSet FOLLOW_209_in_builtInCall5554 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25714  5
     public static final BitSet FOLLOW_expression_in_builtInCall5556 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25715  5
     public static final BitSet FOLLOW_210_in_builtInCall5558 = new BitSet(new long[]{0x0000000000000002L});
 25716  5
     public static final BitSet FOLLOW_CONCAT_in_builtInCall5574 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25717  5
     public static final BitSet FOLLOW_expressionList_in_builtInCall5576 = new BitSet(new long[]{0x0000000000000002L});
 25718  5
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall5592 = new BitSet(new long[]{0x0000000000000002L});
 25719  5
     public static final BitSet FOLLOW_strReplaceExpression_in_builtInCall5604 = new BitSet(new long[]{0x0000000000000002L});
 25720  5
     public static final BitSet FOLLOW_STRLEN_in_builtInCall5616 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25721  5
     public static final BitSet FOLLOW_209_in_builtInCall5618 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25722  5
     public static final BitSet FOLLOW_expression_in_builtInCall5620 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25723  5
     public static final BitSet FOLLOW_210_in_builtInCall5622 = new BitSet(new long[]{0x0000000000000002L});
 25724  5
     public static final BitSet FOLLOW_UCASE_in_builtInCall5638 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25725  5
     public static final BitSet FOLLOW_209_in_builtInCall5640 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25726  5
     public static final BitSet FOLLOW_expression_in_builtInCall5642 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25727  5
     public static final BitSet FOLLOW_210_in_builtInCall5644 = new BitSet(new long[]{0x0000000000000002L});
 25728  5
     public static final BitSet FOLLOW_LCASE_in_builtInCall5660 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25729  5
     public static final BitSet FOLLOW_209_in_builtInCall5662 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25730  5
     public static final BitSet FOLLOW_expression_in_builtInCall5664 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25731  5
     public static final BitSet FOLLOW_210_in_builtInCall5666 = new BitSet(new long[]{0x0000000000000002L});
 25732  5
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall5682 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25733  5
     public static final BitSet FOLLOW_209_in_builtInCall5684 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25734  5
     public static final BitSet FOLLOW_expression_in_builtInCall5686 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25735  5
     public static final BitSet FOLLOW_210_in_builtInCall5688 = new BitSet(new long[]{0x0000000000000002L});
 25736  5
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall5704 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25737  5
     public static final BitSet FOLLOW_209_in_builtInCall5706 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25738  5
     public static final BitSet FOLLOW_expression_in_builtInCall5708 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25739  5
     public static final BitSet FOLLOW_211_in_builtInCall5710 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25740  5
     public static final BitSet FOLLOW_expression_in_builtInCall5712 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25741  5
     public static final BitSet FOLLOW_210_in_builtInCall5714 = new BitSet(new long[]{0x0000000000000002L});
 25742  5
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall5732 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25743  5
     public static final BitSet FOLLOW_209_in_builtInCall5734 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25744  5
     public static final BitSet FOLLOW_expression_in_builtInCall5736 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25745  5
     public static final BitSet FOLLOW_211_in_builtInCall5738 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25746  5
     public static final BitSet FOLLOW_expression_in_builtInCall5740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25747  5
     public static final BitSet FOLLOW_210_in_builtInCall5742 = new BitSet(new long[]{0x0000000000000002L});
 25748  5
     public static final BitSet FOLLOW_STRENDS_in_builtInCall5760 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25749  5
     public static final BitSet FOLLOW_209_in_builtInCall5762 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25750  5
     public static final BitSet FOLLOW_expression_in_builtInCall5764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25751  5
     public static final BitSet FOLLOW_211_in_builtInCall5766 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25752  5
     public static final BitSet FOLLOW_expression_in_builtInCall5768 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25753  5
     public static final BitSet FOLLOW_210_in_builtInCall5770 = new BitSet(new long[]{0x0000000000000002L});
 25754  5
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall5788 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25755  5
     public static final BitSet FOLLOW_209_in_builtInCall5790 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25756  5
     public static final BitSet FOLLOW_expression_in_builtInCall5792 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25757  5
     public static final BitSet FOLLOW_211_in_builtInCall5794 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25758  5
     public static final BitSet FOLLOW_expression_in_builtInCall5796 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25759  5
     public static final BitSet FOLLOW_210_in_builtInCall5798 = new BitSet(new long[]{0x0000000000000002L});
 25760  5
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall5816 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25761  5
     public static final BitSet FOLLOW_209_in_builtInCall5818 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25762  5
     public static final BitSet FOLLOW_expression_in_builtInCall5820 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25763  5
     public static final BitSet FOLLOW_211_in_builtInCall5822 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25764  5
     public static final BitSet FOLLOW_expression_in_builtInCall5824 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25765  5
     public static final BitSet FOLLOW_210_in_builtInCall5826 = new BitSet(new long[]{0x0000000000000002L});
 25766  5
     public static final BitSet FOLLOW_YEAR_in_builtInCall5844 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25767  5
     public static final BitSet FOLLOW_209_in_builtInCall5846 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25768  5
     public static final BitSet FOLLOW_expression_in_builtInCall5848 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25769  5
     public static final BitSet FOLLOW_210_in_builtInCall5850 = new BitSet(new long[]{0x0000000000000002L});
 25770  5
     public static final BitSet FOLLOW_MONTH_in_builtInCall5866 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25771  5
     public static final BitSet FOLLOW_209_in_builtInCall5868 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25772  5
     public static final BitSet FOLLOW_expression_in_builtInCall5870 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25773  5
     public static final BitSet FOLLOW_210_in_builtInCall5872 = new BitSet(new long[]{0x0000000000000002L});
 25774  5
     public static final BitSet FOLLOW_DAY_in_builtInCall5888 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25775  5
     public static final BitSet FOLLOW_209_in_builtInCall5890 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25776  5
     public static final BitSet FOLLOW_expression_in_builtInCall5892 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25777  5
     public static final BitSet FOLLOW_210_in_builtInCall5894 = new BitSet(new long[]{0x0000000000000002L});
 25778  5
     public static final BitSet FOLLOW_HOURS_in_builtInCall5910 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25779  5
     public static final BitSet FOLLOW_209_in_builtInCall5912 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25780  5
     public static final BitSet FOLLOW_expression_in_builtInCall5914 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25781  5
     public static final BitSet FOLLOW_210_in_builtInCall5916 = new BitSet(new long[]{0x0000000000000002L});
 25782  5
     public static final BitSet FOLLOW_MINUTES_in_builtInCall5932 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25783  5
     public static final BitSet FOLLOW_209_in_builtInCall5934 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25784  5
     public static final BitSet FOLLOW_expression_in_builtInCall5936 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25785  5
     public static final BitSet FOLLOW_210_in_builtInCall5938 = new BitSet(new long[]{0x0000000000000002L});
 25786  5
     public static final BitSet FOLLOW_SECONDS_in_builtInCall5954 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25787  5
     public static final BitSet FOLLOW_209_in_builtInCall5956 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25788  5
     public static final BitSet FOLLOW_expression_in_builtInCall5958 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25789  5
     public static final BitSet FOLLOW_210_in_builtInCall5960 = new BitSet(new long[]{0x0000000000000002L});
 25790  5
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall5976 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25791  5
     public static final BitSet FOLLOW_209_in_builtInCall5978 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25792  5
     public static final BitSet FOLLOW_expression_in_builtInCall5980 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25793  5
     public static final BitSet FOLLOW_210_in_builtInCall5982 = new BitSet(new long[]{0x0000000000000002L});
 25794  5
     public static final BitSet FOLLOW_TZ_in_builtInCall5998 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25795  5
     public static final BitSet FOLLOW_209_in_builtInCall6000 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25796  5
     public static final BitSet FOLLOW_expression_in_builtInCall6002 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25797  5
     public static final BitSet FOLLOW_210_in_builtInCall6004 = new BitSet(new long[]{0x0000000000000002L});
 25798  5
     public static final BitSet FOLLOW_NOW_in_builtInCall6020 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25799  5
     public static final BitSet FOLLOW_nil_in_builtInCall6022 = new BitSet(new long[]{0x0000000000000002L});
 25800  5
     public static final BitSet FOLLOW_MD5_in_builtInCall6034 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25801  5
     public static final BitSet FOLLOW_209_in_builtInCall6036 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25802  5
     public static final BitSet FOLLOW_expression_in_builtInCall6038 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25803  5
     public static final BitSet FOLLOW_210_in_builtInCall6040 = new BitSet(new long[]{0x0000000000000002L});
 25804  5
     public static final BitSet FOLLOW_SHA1_in_builtInCall6056 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25805  5
     public static final BitSet FOLLOW_209_in_builtInCall6058 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25806  5
     public static final BitSet FOLLOW_expression_in_builtInCall6060 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25807  5
     public static final BitSet FOLLOW_210_in_builtInCall6062 = new BitSet(new long[]{0x0000000000000002L});
 25808  5
     public static final BitSet FOLLOW_SHA256_in_builtInCall6078 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25809  5
     public static final BitSet FOLLOW_209_in_builtInCall6080 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25810  5
     public static final BitSet FOLLOW_expression_in_builtInCall6082 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25811  5
     public static final BitSet FOLLOW_210_in_builtInCall6084 = new BitSet(new long[]{0x0000000000000002L});
 25812  5
     public static final BitSet FOLLOW_SHA384_in_builtInCall6100 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25813  5
     public static final BitSet FOLLOW_209_in_builtInCall6102 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25814  5
     public static final BitSet FOLLOW_expression_in_builtInCall6104 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25815  5
     public static final BitSet FOLLOW_210_in_builtInCall6106 = new BitSet(new long[]{0x0000000000000002L});
 25816  5
     public static final BitSet FOLLOW_SHA512_in_builtInCall6122 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25817  5
     public static final BitSet FOLLOW_209_in_builtInCall6124 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25818  5
     public static final BitSet FOLLOW_expression_in_builtInCall6126 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25819  5
     public static final BitSet FOLLOW_210_in_builtInCall6128 = new BitSet(new long[]{0x0000000000000002L});
 25820  5
     public static final BitSet FOLLOW_COALESCE_in_builtInCall6144 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25821  5
     public static final BitSet FOLLOW_expressionList_in_builtInCall6146 = new BitSet(new long[]{0x0000000000000002L});
 25822  5
     public static final BitSet FOLLOW_IF_in_builtInCall6162 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25823  5
     public static final BitSet FOLLOW_209_in_builtInCall6164 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25824  5
     public static final BitSet FOLLOW_expression_in_builtInCall6168 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25825  5
     public static final BitSet FOLLOW_211_in_builtInCall6170 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25826  5
     public static final BitSet FOLLOW_expression_in_builtInCall6174 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25827  5
     public static final BitSet FOLLOW_211_in_builtInCall6176 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25828  5
     public static final BitSet FOLLOW_expression_in_builtInCall6180 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25829  5
     public static final BitSet FOLLOW_210_in_builtInCall6182 = new BitSet(new long[]{0x0000000000000002L});
 25830  5
     public static final BitSet FOLLOW_STRLANG_in_builtInCall6205 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25831  5
     public static final BitSet FOLLOW_209_in_builtInCall6207 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25832  5
     public static final BitSet FOLLOW_expression_in_builtInCall6209 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25833  5
     public static final BitSet FOLLOW_211_in_builtInCall6211 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25834  5
     public static final BitSet FOLLOW_expression_in_builtInCall6213 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25835  5
     public static final BitSet FOLLOW_210_in_builtInCall6215 = new BitSet(new long[]{0x0000000000000002L});
 25836  5
     public static final BitSet FOLLOW_STRDT_in_builtInCall6233 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25837  5
     public static final BitSet FOLLOW_209_in_builtInCall6235 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25838  5
     public static final BitSet FOLLOW_expression_in_builtInCall6237 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25839  5
     public static final BitSet FOLLOW_211_in_builtInCall6239 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25840  5
     public static final BitSet FOLLOW_expression_in_builtInCall6241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25841  5
     public static final BitSet FOLLOW_210_in_builtInCall6243 = new BitSet(new long[]{0x0000000000000002L});
 25842  5
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall6261 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25843  5
     public static final BitSet FOLLOW_209_in_builtInCall6263 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25844  5
     public static final BitSet FOLLOW_expression_in_builtInCall6265 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25845  5
     public static final BitSet FOLLOW_211_in_builtInCall6267 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25846  5
     public static final BitSet FOLLOW_expression_in_builtInCall6269 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25847  5
     public static final BitSet FOLLOW_210_in_builtInCall6271 = new BitSet(new long[]{0x0000000000000002L});
 25848  5
     public static final BitSet FOLLOW_ISIRI_in_builtInCall6289 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25849  5
     public static final BitSet FOLLOW_209_in_builtInCall6291 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25850  5
     public static final BitSet FOLLOW_expression_in_builtInCall6293 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25851  5
     public static final BitSet FOLLOW_210_in_builtInCall6295 = new BitSet(new long[]{0x0000000000000002L});
 25852  5
     public static final BitSet FOLLOW_ISURI_in_builtInCall6311 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25853  5
     public static final BitSet FOLLOW_209_in_builtInCall6313 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25854  5
     public static final BitSet FOLLOW_expression_in_builtInCall6315 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25855  5
     public static final BitSet FOLLOW_210_in_builtInCall6317 = new BitSet(new long[]{0x0000000000000002L});
 25856  5
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall6333 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25857  5
     public static final BitSet FOLLOW_209_in_builtInCall6335 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25858  5
     public static final BitSet FOLLOW_expression_in_builtInCall6337 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25859  5
     public static final BitSet FOLLOW_210_in_builtInCall6339 = new BitSet(new long[]{0x0000000000000002L});
 25860  5
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall6356 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25861  5
     public static final BitSet FOLLOW_209_in_builtInCall6358 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25862  5
     public static final BitSet FOLLOW_expression_in_builtInCall6360 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25863  5
     public static final BitSet FOLLOW_210_in_builtInCall6362 = new BitSet(new long[]{0x0000000000000002L});
 25864  5
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall6378 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25865  5
     public static final BitSet FOLLOW_209_in_builtInCall6380 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25866  5
     public static final BitSet FOLLOW_expression_in_builtInCall6382 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25867  5
     public static final BitSet FOLLOW_210_in_builtInCall6384 = new BitSet(new long[]{0x0000000000000002L});
 25868  5
     public static final BitSet FOLLOW_regexExpression_in_builtInCall6400 = new BitSet(new long[]{0x0000000000000002L});
 25869  5
     public static final BitSet FOLLOW_existsFunction_in_builtInCall6412 = new BitSet(new long[]{0x0000000000000002L});
 25870  5
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall6424 = new BitSet(new long[]{0x0000000000000002L});
 25871  5
     public static final BitSet FOLLOW_REGEX_in_regexExpression6445 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25872  5
     public static final BitSet FOLLOW_209_in_regexExpression6447 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25873  5
     public static final BitSet FOLLOW_expression_in_regexExpression6449 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25874  5
     public static final BitSet FOLLOW_211_in_regexExpression6451 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25875  5
     public static final BitSet FOLLOW_expression_in_regexExpression6453 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25876  5
     public static final BitSet FOLLOW_211_in_regexExpression6456 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25877  5
     public static final BitSet FOLLOW_expression_in_regexExpression6458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25878  5
     public static final BitSet FOLLOW_210_in_regexExpression6462 = new BitSet(new long[]{0x0000000000000002L});
 25879  5
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression6492 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25880  5
     public static final BitSet FOLLOW_209_in_subStringExpression6494 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25881  5
     public static final BitSet FOLLOW_expression_in_subStringExpression6496 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25882  5
     public static final BitSet FOLLOW_211_in_subStringExpression6498 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25883  5
     public static final BitSet FOLLOW_expression_in_subStringExpression6500 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25884  5
     public static final BitSet FOLLOW_211_in_subStringExpression6503 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25885  5
     public static final BitSet FOLLOW_expression_in_subStringExpression6505 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25886  5
     public static final BitSet FOLLOW_210_in_subStringExpression6509 = new BitSet(new long[]{0x0000000000000002L});
 25887  5
     public static final BitSet FOLLOW_REPLACE_in_strReplaceExpression6543 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25888  5
     public static final BitSet FOLLOW_209_in_strReplaceExpression6545 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25889  5
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6547 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25890  5
     public static final BitSet FOLLOW_211_in_strReplaceExpression6549 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25891  5
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6551 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000080000L});
 25892  5
     public static final BitSet FOLLOW_211_in_strReplaceExpression6553 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25893  5
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6555 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x00000000000C0000L});
 25894  5
     public static final BitSet FOLLOW_211_in_strReplaceExpression6558 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25895  5
     public static final BitSet FOLLOW_expression_in_strReplaceExpression6560 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25896  5
     public static final BitSet FOLLOW_210_in_strReplaceExpression6564 = new BitSet(new long[]{0x0000000000000002L});
 25897  5
     public static final BitSet FOLLOW_EXISTS_in_existsFunction6590 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25898  5
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction6592 = new BitSet(new long[]{0x0000000000000002L});
 25899  5
     public static final BitSet FOLLOW_NOT_in_notExistsFunction6617 = new BitSet(new long[]{0x2000000000000000L});
 25900  5
     public static final BitSet FOLLOW_EXISTS_in_notExistsFunction6619 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000001000000L});
 25901  5
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction6621 = new BitSet(new long[]{0x0000000000000002L});
 25902  5
     public static final BitSet FOLLOW_COUNT_in_aggregate6646 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25903  5
     public static final BitSet FOLLOW_209_in_aggregate6648 = new BitSet(new long[]{0x24E41F2929818020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25904  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6650 = new BitSet(new long[]{0x24E01F2929818020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25905  5
     public static final BitSet FOLLOW_ASTERISK_in_aggregate6654 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25906  5
     public static final BitSet FOLLOW_expression_in_aggregate6658 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25907  5
     public static final BitSet FOLLOW_210_in_aggregate6661 = new BitSet(new long[]{0x0000000000000002L});
 25908  5
     public static final BitSet FOLLOW_SUM_in_aggregate6684 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25909  5
     public static final BitSet FOLLOW_209_in_aggregate6686 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25910  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6688 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25911  5
     public static final BitSet FOLLOW_expression_in_aggregate6691 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25912  5
     public static final BitSet FOLLOW_210_in_aggregate6693 = new BitSet(new long[]{0x0000000000000002L});
 25913  5
     public static final BitSet FOLLOW_MIN_in_aggregate6712 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25914  5
     public static final BitSet FOLLOW_209_in_aggregate6714 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25915  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6716 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25916  5
     public static final BitSet FOLLOW_expression_in_aggregate6719 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25917  5
     public static final BitSet FOLLOW_210_in_aggregate6721 = new BitSet(new long[]{0x0000000000000002L});
 25918  5
     public static final BitSet FOLLOW_MAX_in_aggregate6740 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25919  5
     public static final BitSet FOLLOW_209_in_aggregate6742 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25920  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6744 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25921  5
     public static final BitSet FOLLOW_expression_in_aggregate6747 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25922  5
     public static final BitSet FOLLOW_210_in_aggregate6749 = new BitSet(new long[]{0x0000000000000002L});
 25923  5
     public static final BitSet FOLLOW_AVG_in_aggregate6768 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25924  5
     public static final BitSet FOLLOW_209_in_aggregate6770 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25925  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6772 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25926  5
     public static final BitSet FOLLOW_expression_in_aggregate6775 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25927  5
     public static final BitSet FOLLOW_210_in_aggregate6777 = new BitSet(new long[]{0x0000000000000002L});
 25928  5
     public static final BitSet FOLLOW_SAMPLE_in_aggregate6796 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25929  5
     public static final BitSet FOLLOW_209_in_aggregate6798 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25930  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6800 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25931  5
     public static final BitSet FOLLOW_expression_in_aggregate6803 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25932  5
     public static final BitSet FOLLOW_210_in_aggregate6805 = new BitSet(new long[]{0x0000000000000002L});
 25933  5
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate6824 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25934  5
     public static final BitSet FOLLOW_209_in_aggregate6826 = new BitSet(new long[]{0x24E41F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25935  5
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6828 = new BitSet(new long[]{0x24E01F2929810020L,0x0094AF0BFB398405L,0x839FFE743F200340L,0x0000000000030643L});
 25936  5
     public static final BitSet FOLLOW_expression_in_aggregate6831 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000140000L});
 25937  5
     public static final BitSet FOLLOW_212_in_aggregate6834 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 25938  5
     public static final BitSet FOLLOW_SEPARATOR_in_aggregate6836 = new BitSet(new long[]{0x1000000000000000L});
 25939  5
     public static final BitSet FOLLOW_EQUAL_in_aggregate6838 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0003C00000000000L});
 25940  5
     public static final BitSet FOLLOW_string_in_aggregate6840 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000040000L});
 25941  5
     public static final BitSet FOLLOW_210_in_aggregate6844 = new BitSet(new long[]{0x0000000000000002L});
 25942  5
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction6879 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000020000L});
 25943  5
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction6881 = new BitSet(new long[]{0x0000000000000002L});
 25944  5
     public static final BitSet FOLLOW_string_in_rdfLiteral6914 = new BitSet(new long[]{0x0000000000000002L,0x0000000400000000L,0x0000000000000000L,0x0000000000800000L});
 25945  5
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral6917 = new BitSet(new long[]{0x0000000000000002L});
 25946  5
     public static final BitSet FOLLOW_215_in_rdfLiteral6922 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L,0x0000000000000300L});
 25947  5
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral6924 = new BitSet(new long[]{0x0000000000000002L});
 25948  5
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral6958 = new BitSet(new long[]{0x0000000000000002L});
 25949  5
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral6966 = new BitSet(new long[]{0x0000000000000002L});
 25950  5
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral6974 = new BitSet(new long[]{0x0000000000000002L});
 25951  5
     public static final BitSet FOLLOW_IRI_REF_in_iriRef7157 = new BitSet(new long[]{0x0000000000000002L});
 25952  5
     public static final BitSet FOLLOW_prefixedName_in_iriRef7165 = new BitSet(new long[]{0x0000000000000002L});
 25953  5
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode7207 = new BitSet(new long[]{0x0000000000000002L});
 25954  5
     public static final BitSet FOLLOW_anon_in_blankNode7215 = new BitSet(new long[]{0x0000000000000002L});
 25955  5
     public static final BitSet FOLLOW_213_in_anon7232 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000400000L});
 25956  5
     public static final BitSet FOLLOW_214_in_anon7234 = new BitSet(new long[]{0x0000000000000002L});
 25957  
 
 25958  
 }